DeepCoder-14B-Preview : un modèle open-source qui excelle dans la génération de code

Introduction générale

DeepCoder-14B-Preview est un modèle de génération de code open source développé par l'équipe d'Agentica et publié sur la plateforme Hugging Face. Il est basé sur DeepSeek-R1-Distilled-Qwen-14B, optimisé par des techniques d'apprentissage par renforcement distribué (RL), et est capable de gérer jusqu'à 64K jeton des contextes très longs. Le modèle compte 14 milliards de paramètres et a atteint une précision Pass@1 de 60,6% lors des tests LiveCodeBench v5 (du 1er août 2024 au 1er février 2025), soit une amélioration de 8% par rapport au modèle de base et une performance proche de l'o3-mini d'OpenAI. Il est entièrement open source, y compris les poids du modèle, les données d'entraînement et les scripts. L'objectif de DeepCoder est d'aider les développeurs à écrire des codes complexes de manière efficace, en particulier pour les concours de programmation et les projets à grande échelle.

Liste des fonctions

• Générer du code long : prend en charge des contextes allant jusqu'à 64 000 jetons, et peut générer et gérer du code très long.
• Résultat très précis : 60,6% Pass@1 dans LiveCodeBench v5 pour une qualité de code fiable.
• Open source disponible : les fichiers de modèles, les ensembles de données et les scripts de formation peuvent être téléchargés et personnalisés gratuitement.
• Prise en charge d'un large éventail de tâches de programmation : convient pour répondre à des questions de concours, déboguer du code et développer des projets.
• Raisonnement contextuel long : optimisé par les techniques GRPO+ et DAPO pour garantir des capacités de génération de codes longs.

Utiliser l'aide

DeepCoder-14B-Preview est un outil puissant qui peut vous aider à générer du code ou à gérer des tâches de programmation complexes. Vous trouverez ci-dessous un guide d'installation et d'utilisation détaillé.

Processus d'installation

Pour utiliser DeepCoder-14B-Preview localement, vous devez préparer l'environnement et télécharger le modèle. Les étapes sont les suivantes :

1. Préparer le matériel et les logiciels
   • Un ordinateur équipé d'un GPU est nécessaire, NVIDIA H100 ou une carte graphique avec au moins 24 Go de RAM est recommandée.
   • Installation de Python 3.10 : Exécuter conda create -n deepcoder python=3.10 -yActivez ensuite l'environnement conda activate deepcoder.
   • Installer les bibliothèques dépendantes : exécuter pip install transformers torch huggingface_hub vllm.
2. Télécharger les modèles
   • Visitez la page officielle à l'adresse suivante : https://huggingface.co/agentica-org/DeepCoder-14B-Preview.
   • Dans la rubrique "Fichiers et versions", vous trouverez les fichiers du modèle (par ex. model-00001-of-00012.safetensors).
   • Utilisez la commande download :

     huggingface-cli download agentica-org/DeepCoder-14B-Preview --local-dir ./DeepCoder-14B
     

   • Après le téléchargement, les fichiers du modèle sont sauvegardés localement ./DeepCoder-14B Dossier.
3. Modèles de chargement
   • Charger le modèle en Python :

     from transformers import AutoModelForCausalLM, AutoTokenizer
     model_path = "./DeepCoder-14B"
     model = AutoModelForCausalLM.from_pretrained(model_path, torch_dtype="auto", device_map="auto")
     tokenizer = AutoTokenizer.from_pretrained(model_path)
     

   • Le modèle est alors chargé sur le GPU, prêt à être utilisé.

Comment utiliser les principales fonctionnalités

Le cœur de DeepCoder est la génération de code et la gestion des contextes longs. Voici comment cela fonctionne :

Générer le code

1. Exigences en matière de programmation des entrées
   • Préparez un problème, tel que "Écrire une fonction Python qui trouve la valeur maximale dans un tableau".
   • Convertir les exigences en texte :

     prompt = "写一个 Python 函数，找出数组中的最大值"
     

2. Générer le code
   • Utilisez le code suivant pour générer la réponse :

     inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
     outputs = model.generate(**inputs, max_new_tokens=512, temperature=0.6, top_p=0.95)
     result = tokenizer.decode(outputs[0], skip_special_tokens=True)
     print(result)
     

   • Sorties possibles :

     def find_max(arr):
     if not arr:
     return None
     max_value = arr[0]
     for num in arr:
     if num > max_value:
     max_value = num
     return max_value
     

3. Génération optimisée
   • Si un code plus long est nécessaire, ajuster le max_new_tokens est égal ou supérieur à 1024.
   • mettre en place max_tokens=64000 Les performances optimales à long terme sont obtenues.

Gestion des contextes longs

1. Saisir le code long
   • Supposons que vous ayez un code d'une longueur de 32 000 jetons et que vous souhaitiez que le modèle le renouvelle :

     long_code = "def process_data(data):\n    # 几千行代码...\n    return processed_data"
     prompt = long_code + "\n请为这个函数添加异常处理"
     

2. Générer une suite
   • Saisir et générer :

     inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
     outputs = model.generate(**inputs, max_new_tokens=512, temperature=0.6, top_p=0.95)
     result = tokenizer.decode(outputs[0], skip_special_tokens=True)
     print(result)
     

   • Le résultat peut être :

     def process_data(data):
     try:
     # 几千行代码...
     return processed_data
     except Exception as e:
     print(f"错误: {e}")
     return None
     

3. Résultats de la vérification
   • Vérifiez que le code répond aux exigences. Si ce n'est pas le cas, décrivez les exigences plus clairement.

Fonctions vedettes Procédure d'utilisation

La capacité de DeepCoder à générer des codes longs est son point fort, ce qui le rend adapté aux concours et aux projets à grande échelle.

Résoudre des concours

1. Obtenir le titre
   • Trouvez un sujet dans Codeforces, tel que "Étant donné un tableau, retourner tous les sous-ensembles possibles".
   • Saisissez une description du sujet :

     prompt = "给定一个数组，返回所有可能的子集。例如，输入 [1,2,3]，输出 [[],[1],[2],[3],[1,2],[1,3],[2,3],[1,2,3]]"
     

2. Générer le code
   • Exécutez la commande generate :

     inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
     outputs = model.generate(**inputs, max_new_tokens=512, temperature=0.6, top_p=0.95)
     result = tokenizer.decode(outputs[0], skip_special_tokens=True)
     print(result)
     

   • Le résultat peut être :

     def subsets(nums):
     result = [[]]
     for num in nums:
     result += [curr + [num] for curr in result]
     return result
     

3. Résultats des tests
   • Pour exécuter le code en Python, tapez [1,2,3]Vérifier que la sortie est correcte.

code de débogage

1. Saisir le code de la question
   • Supposons qu'il y ait un morceau de code bogué :

     buggy_code = "def sum_numbers(n):\n    total = 0\n    for i in range(n)\n        total += i\n    return total"
     prompt = buggy_code + "\n这段代码有语法错误，请修复"
     

2. Générer des correctifs
   • Saisir et générer :

     inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
     outputs = model.generate(**inputs, max_new_tokens=512, temperature=0.6, top_p=0.95)
     result = tokenizer.decode(outputs[0], skip_special_tokens=True)
     print(result)
     

   • Le résultat peut être :

     def sum_numbers(n):
     total = 0
     for i in range(n):
     total += i
     return total
     

3. Corrections de la vérification
   • Vérifiez que la syntaxe est correcte et exécutez le code pour confirmer le résultat.

Recommandations d'utilisation

• N'ajoutez pas d'invite système, énoncez l'exigence directement dans l'invite utilisateur.
• mettre en place temperature=0.6 répondre en chantant top_p=0.95 pour des résultats optimaux.
• commandant en chef (militaire) max_tokens La valeur 64000 permet de tirer parti des contextes longs.

scénario d'application

1. concours de programmation
   DeepCoder génère rapidement des réponses aux questions du concours et convient aux tâches complexes dans LiveCodeBench ou Codeforces.
2. Développement de projets à grande échelle
   Il peut générer de longs modules de code pour aider les développeurs à mener à bien de grands projets.
3. Éducation et apprentissage
   Les étudiants peuvent l'utiliser pour générer des exemples de code, apprendre des algorithmes ou déboguer des travaux.

QA

1. DeepCoder-14B-Preview est-il gratuit ?
   Oui, il est sous licence MIT, complètement open source et libre d'utilisation pour tout le monde.
2. Quel est le matériel nécessaire pour le faire fonctionner ?
   Il est recommandé d'utiliser un ordinateur équipé d'un GPU et d'au moins 24 Go de mémoire vidéo. Si vous utilisez un processeur, l'exécution sera beaucoup plus lente.
3. Quels sont les langages de programmation pris en charge ?
   Il est principalement spécialisé dans le langage Python, mais peut également générer du code en Java, C++ et d'autres langages, en fonction de la clarté de l'invite.