Platform For AI:Entraîner, évaluer, compresser et déployer Qwen2.5-Coder

Présentation du modèle

Qwen2,5-Coder est une série de modèles puissants, axés sur le code, qui prennent en charge une longueur de contexte allant jusqu'à 128 K jetons et sont compatibles avec 92 langages de programmation. Ces modèles excellent dans diverses tâches liées au code, notamment la génération de code multilingue, la complétion de code et la réparation de code. La variante affinée pour les instructions, Qwen2,5-Coder-Instruct, s'appuie sur le modèle de base pour offrir des performances améliorées sur ces tâches ainsi qu'une excellente généralisation.

Les principales caractéristiques sont les suivantes :

• Capacité de programmation multilingue : Qwen2,5-Coder-Instruct obtient d'excellents résultats sur le benchmark McEval, qui couvre plus de 40 langages, y compris des langages de programmation de niche.

• Capacité de raisonnement sur le code : Le modèle atteint des résultats impressionnants sur le benchmark CRUXEval, mettant en évidence ses fortes capacités de raisonnement sur le code. Ce raisonnement amélioré est également corrélé à de meilleures performances sur des tâches complexes de suivi d'instructions.

• Capacité mathématique : Discipline fondamentale pour la programmation, les mathématiques constituent un autre domaine où le modèle excelle, démontrant ainsi ses capacités complètes dans les domaines STEM.

• Capacités générales : Qwen2,5-Coder-Instruct hérite des puissantes capacités générales du modèle de base Qwen2,5, garantissant stabilité et large applicabilité sur une vaste gamme de tâches.

Configuration requise

Déploiement et appel du modèle

from openai import OpenAI
# 1. Configure the client.
# Replace <EAS_TOKEN> with the Token from the Invocation Information panel.
openai_api_key = "<EAS_TOKEN>"
# Replace <EAS_ENDPOINT> with the Public Endpoint from the Invocation Information panel.
openai_api_base = "<EAS_ENDPOINT>/v1"
client = OpenAI(
    api_key=openai_api_key,
    base_url=openai_api_base,
)
# 2. Get the model name.
# For BladeLLM, set model = "". BladeLLM does not require the model parameter and does not support using client.models.list() to get the model name. Set it to an empty string to comply with the mandatory parameter requirement of the OpenAI SDK.
models = client.models.list()
model = models.data[0].id
print(model)
# 3. Initiate a chat completion request.
# Both streaming (stream=True) and non-streaming (stream=False) outputs are supported.
stream = True
chat_completion = client.chat.completions.create(
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "hello"},          
    ],
    model=model,
    top_p=0.8,
    temperature=0.7,
    max_tokens=1024,
    stream=stream,
)
if stream:
    for chunk in chat_completion:
        print(chunk.choices[0].delta.content, end="")
else:
    result = chat_completion.choices[0].message.content
    print(result)

Affinage du modèle

Model Gallery propose deux algorithmes d'affinage prêts à l'emploi pour le modèle Qwen2,5-Coder-32B-Instruct : l'affinage supervisé (SFT) et l'optimisation directe des préférences (DPO).

[
  {
    "instruction": "Create a function to calculate the sum of a sequence of integers.",
    "output": "# Python code\ndef sum_sequence(sequence):\n  sum = 0\n  for num in sequence:\n    sum += num\n  return sum"
  },
  {
    "instruction": "Generate a Python code for crawling a website for a specific type of data.",
    "output": "import requests\nimport re\n\ndef crawl_website_for_phone_numbers(website):\n    response = requests.get(website)\n    phone_numbers = re.findall('\\d{3}-\\d{3}-\\d{4}', response.text)\n    return phone_numbers\n    \nif __name__ == '__main__':\n    print(crawl_website_for_phone_numbers('www.example.com'))"
  }
]

[
  {
    "prompt": "Create a function to calculate the sum of a sequence of integers.",
    "chosen": "# Python code\ndef sum_sequence(sequence):\n  sum = 0\n  for num in sequence:\n    sum += num\n  return sum",
    "rejected": "[x*x for x in [1, 2, 3, 5, 8, 13]]"
  },
  {
    "prompt": "Generate a Python code for crawling a website for a specific type of data.",
    "chosen": "import requests\nimport re\n\ndef crawl_website_for_phone_numbers(website):\n    response = requests.get(website)\n    phone_numbers = re.findall('\\d{3}-\\d{3}-\\d{4}', response.text)\n    return phone_numbers\n    \nif __name__ == '__main__':\n    print(crawl_website_for_phone_numbers('www.example.com'))",
    "rejected": "def remove_duplicates(string): \n    result = \"\" \n    prev = '' \n\n    for char in string:\n        if char != prev: \n            result += char\n            prev = char\n    return result\n\nresult = remove_duplicates(\"AAABBCCCD\")\nprint(result)"
  }
]

1. Sur la page Model Gallery, cliquez sur la carte du modèle Qwen2,5-Coder-32B-Instruct pour accéder à la page des détails du modèle.

2. Sur la page des détails du modèle, cliquez sur Train dans le coin supérieur droit. Configurez les paramètres suivants :

   • Configuration du jeu de données : Après avoir préparé vos données, téléchargez-les dans un compartiment Object Storage Service (OSS) ou sélectionnez un jeu de données sur NAS ou CPFS en spécifiant un objet de jeu de données. Vous pouvez également utiliser un jeu de données public fourni par PAI pour soumettre une tâche et tester l'algorithme.

   • Configuration des ressources de calcul : L'algorithme nécessite un GPU disposant d'au moins 80 Go de VRAM. Assurez-vous de disposer de ressources de calcul suffisantes dans votre quota de ressources sélectionné. Pour les spécifications de ressources requises par les autres tailles de modèle, consultez Configuration requise.

   • Configuration des hyperparamètres : Le tableau ci-dessous répertorie les hyperparamètres d'entraînement. Vous pouvez ajuster ces valeurs ou utiliser les valeurs par défaut.

     Configuration des hyperparamètres

     Hyperparamètre	Type	Valeur par défaut	Obligatoire	Description
     training_strategy	String	sft	Oui	L'algorithme d'entraînement. Valeurs valides : SFT et DPO.
     learning_rate	Float	5e-5	Oui	Le taux d'apprentissage, qui contrôle l'ampleur des ajustements des poids du modèle.
     num_train_epochs	Integer	1	Oui	Le nombre d'époques d'entraînement.
     per_device_train_batch_size	Integer	1	Oui	Le nombre d'échantillons traités par chaque GPU lors de chaque itération d'entraînement. Une taille de lot plus grande peut améliorer l'efficacité, mais augmente également les exigences en matière de VRAM.
     seq_length	Integer	128	Oui	La longueur maximale de séquence (en jetons) pour les entrées du modèle.
     lora_dim	Integer	32	Non	La dimension LoRA. Si lora_dim > 0, un entraînement léger LoRA ou QLoRA est utilisé.
     lora_alpha	Integer	32	Non	Le poids LoRA. Ce paramètre est actif lorsque lora_dim > 0 (un entraînement LoRA ou QLoRA est utilisé).
     dpo_beta	Float	0.1	Non	Contrôle la dépendance du modèle vis-à-vis des informations de préférence pendant l'entraînement.
     load_in_4bit	Boolean	false	Non	Indique si le modèle doit être chargé avec une précision de 4 bits. Si lora_dim > 0, load_in_4bit est défini sur true et load_in_8bit sur false, ce qui permet un entraînement QLoRA léger en 4 bits.
     load_in_8bit	Boolean	false	Non	Indique si le modèle doit être chargé avec une précision de 8 bits. Si lora_dim > 0, load_in_4bit est défini sur false et load_in_8bit sur true, ce qui permet un entraînement QLoRA léger en 8 bits.
     gradient_accumulation_steps	Integer	8	Non	Le nombre d'étapes pour l'accumulation du gradient.
     apply_chat_template	Boolean	true	Non	Indique s'il faut appliquer le modèle de conversation par défaut du modèle aux données d'entraînement. Pour les modèles de la série Qwen2, le format est le suivant : Question :<|im_end|>\n<|im_start|>user\n + instruction + <|im_end|>\n Réponse : <|im_start|>assistant\n + output + <|im_end|>\n
     system_prompt	String	You are a helpful assistant	Non	L'invite système utilisée pour l'entraînement du modèle.

3. Cliquez sur Train. Model Gallery vous redirige automatiquement vers la page des détails de la tâche, où vous pouvez surveiller l'état de l'entraînement et consulter les journaux.

Le modèle entraîné est automatiquement enregistré dans AI Asset - Model Management, où vous pouvez consulter ou déployer le modèle. Pour plus d'informations, consultez Enregistrer et gérer les modèles.

Évaluation du modèle

PAI fournit un algorithme d'évaluation intégré pour le modèle Qwen2,5-Coder-32B-Instruct. Utilisez cet algorithme pour évaluer les performances du modèle d'origine et de vos versions affinées. Pour plus d'informations, consultez Évaluation des modèles et Meilleures pratiques pour l'évaluation des grands modèles de langage.

Compression du modèle

Après l'entraînement, vous pouvez quantifier (compresser) le modèle avant son déploiement afin de réduire ses exigences en matière de stockage et de calcul. Pour plus d'informations, consultez Compression des modèles.

Références

• Présentation du modèle Qwen2,5-Coder

• Facturation pour Quick Start