- Meta a dévoilé Code Llama, un modèle spécialisé dans le code basé sur Llama 2, disponible gratuitement pour la recherche et les usages commerciaux, sous la même licence communautaire
- Code Llama accepte à la fois du code et des prompts en langage naturel, et prend en charge la génération, la complétion et le débogage de code ; il couvre Python, C++, Java, PHP, TypeScript, C#, Bash, etc.
- Les tailles de modèle sont réparties en 7B, 13B, 34B et 70B ; les petits modèles sont avantageux pour une faible latence, tandis que les 34B et 70B visent une meilleure assistance au codage
- Un modèle de base, un modèle spécialisé Python et une variante Instruct adaptée à la compréhension d’instructions en langage naturel sont proposés ; pour la génération de code réelle, l’usage d’Instruct est recommandé
- Lors de ses propres évaluations, Code Llama 34B a obtenu 53,7 % sur HumanEval et 56,2 % sur MBPP ; l’approche consiste à encourager l’évaluation par la communauté et l’amélioration des vulnérabilités grâce à un modèle ouvert spécialisé dans le code
Mode de publication et mise à jour 70B
- Meta a dévoilé Code Llama, un grand modèle de langage capable de générer du code à partir de prompts textuels
- Code Llama vise des performances de pointe parmi les LLM pour le code disponibles publiquement, avec pour objectif de rendre les workflows des développeurs plus rapides et plus efficaces, et d’abaisser la barrière à l’entrée pour les personnes qui apprennent à coder
- Il est proposé gratuitement pour la recherche et les usages commerciaux, et distribué sous la même licence communautaire que Llama 2
- Une mise à jour du 29 janvier 2024 a ajouté Code Llama 70B, le modèle le plus grand et le plus performant de la famille Code Llama
- CodeLlama - 70B : modèle de code de base
- CodeLlama - 70B - Python : modèle 70B spécialisé Python
- Code Llama - 70B - Instruct : modèle 70B affiné pour comprendre les instructions en langage naturel
Un modèle adapté de Llama 2 pour les tâches de code
- Code Llama est une version spécialisée dans le code de Llama 2, entraînée davantage sur un jeu de données spécialisé dans le code
- Il peut recevoir en entrée à la fois du code et des prompts en langage naturel, et être utilisé pour diverses tâches de programmation
- Génération de code
- Génération en langage naturel à propos du code
- Complétion de code
- Débogage
- Un exemple de prompt est une demande en langage naturel comme « écris une fonction qui affiche la suite de Fibonacci »
- Les langages pris en charge incluent Python, C++, Java, PHP, TypeScript(JavaScript), C# et Bash
Tailles des modèles, données d’entraînement et choix de latence
- Code Llama est proposé en tailles de 7B, 13B, 34B et 70B paramètres
- Les modèles hors 70B ont été entraînés sur 500B tokens de code et de données liées au code, tandis que le 70B a été entraîné sur 1T tokens
- Les modèles de base et Instruct en 7B et 13B ont été entraînés avec la capacité fill-in-the-middle(FIM), ce qui permet d’insérer du nouveau code au milieu de code existant
- Cela prend en charge des tâches comme la complétion de code instantanée
- Les coûts de serving et les caractéristiques de latence diffèrent selon la taille du modèle
- Le modèle 7B peut être servi sur un seul GPU
- Les 34B et 70B offrent les meilleurs résultats et une meilleure assistance au codage
- Les 7B et 13B étant plus rapides, ils conviennent mieux aux tâches nécessitant une faible latence, comme la complétion de code en temps réel
- Les modèles Code Llama fournissent une génération stable jusqu’à un contexte de 100 000 tokens
- Tous les modèles ont été entraînés sur des séquences de 16 000 tokens
- Ils montrent des améliorations avec des entrées allant jusqu’à 100 000 tokens
- Les longues séquences d’entrée aident non seulement à générer de longs programmes, mais aussi à transmettre au modèle davantage de contexte d’une base de code, ce qui rend les résultats générés plus pertinents
- Lors du débogage de grandes bases de code, il peut être difficile d’identifier tout le code lié à un problème donné ; les développeurs peuvent donc fournir au modèle de gros blocs de code entiers
Trois variantes : base, Python et Instruct
- La famille Code Llama comprend, outre le modèle de base, un modèle spécialisé Python et une variante Instruct
- Code Llama - Python est un modèle spécialisé par langage, affiné davantage sur 100B tokens de code Python
- Python est le langage le plus souvent benchmarké pour la génération de code
- Python et PyTorch jouent un rôle important dans la communauté IA
- Code Llama - Instruct est une variante ayant fait l’objet d’un fine-tuning d’instructions et d’un alignement
- Son entraînement se poursuit avec des entrées d’instructions en langage naturel et les sorties attendues
- Elle est conçue pour mieux comprendre les résultats attendus par les humains dans les prompts
- Pour la génération de code réelle, il est recommandé d’utiliser Code Llama - Instruct
- Car il a été affiné pour produire des réponses utiles et sûres en langage naturel
- Code Llama et Code Llama - Python ne sont pas recommandés pour les tâches générales en langage naturel
- Les deux modèles ne sont pas conçus pour suivre des instructions en langage naturel
- Code Llama est destiné aux tâches spécialisées dans le code et ne convient pas comme modèle de base pour d’autres tâches
- Les utilisateurs doivent respecter la licence et la politique d’utilisation acceptable
Benchmarks et évaluation de la sécurité
- Meta a utilisé les benchmarks HumanEval et MBPP pour évaluer les performances de Code Llama
- Dans ses propres benchmarks, Code Llama affiche de meilleures performances que les LLM open source spécialisés dans le code et que Llama 2
- Code Llama 34B a obtenu 53,7 % sur HumanEval et 56,2 % sur MBPP
- Il s’agissait du score le plus élevé par rapport aux autres solutions publiques de pointe
- Il a été évalué comme étant au niveau de ChatGPT
- Plusieurs mesures de sécurité ont été appliquées avant la publication, et le risque de génération de code malveillant a été évalué quantitativement dans le cadre d’un red teaming
- Des prompts demandant clairement du code malveillant ont été créés
- Les réponses de Code Llama ont été comparées et notées face à celles de ChatGPT(GPT3.5 Turbo)
- D’après les résultats, Code Llama fournit des réponses plus sûres
- Les détails du red teaming mené par des spécialistes de l’IA responsable, de l’ingénierie en sécurité offensive, du développement de logiciels malveillants et de l’ingénierie logicielle sont disponibles dans le papier de recherche
Ressources publiées et usage responsable
- Les développeurs utilisent déjà les LLM pour de nombreuses tâches, de l’écriture de nouveaux logiciels au débogage de code existant
- Code Llama vise à rendre les workflows des développeurs plus efficaces afin qu’ils puissent se concentrer sur des tâches plus centrées sur l’humain que les tâches répétitives
- Meta estime que les LLM pour le code peuvent bénéficier fortement d’une approche ouverte en matière d’innovation et de sécurité
- Un modèle ouvert spécialisé dans le code permet à la communauté d’évaluer ses capacités, de trouver des problèmes et de corriger des vulnérabilités
- La recette d’entraînement de Code Llama est publiée dans le dépôt GitHub
- Les poids du modèle sont disponibles sur la page Llama
- Le papier de recherche comprend les détails de développement, la méthode de test par benchmark, les limites, les problèmes connus, les mesures d’atténuation et les sujets à étudier à l’avenir
- Le Responsible Use Guide a également été mis à jour afin de fournir des consignes pour développer des modèles downstream de manière responsable
- Politique de contenu et définition des mesures d’atténuation
- Préparation des données
- Fine-tuning du modèle
- Évaluation et amélioration des performances
- Réponse aux risques au niveau des entrées et des sorties
- Mise en place de mécanismes de transparence et de signalement dans les interactions utilisateur
- Les développeurs doivent évaluer les modèles à l’aide de benchmarks spécialisés dans le code et mener des recherches de sécurité sur des cas d’usage comme la génération de logiciels malveillants, de virus informatiques ou de code malveillant
- L’utilisation de jeux de données de sécurité pour des évaluations automatiques et humaines, ainsi que le red teaming fondé sur des prompts adversariaux, sont également recommandés
Prochaines étapes et ressources de référence
- Code Llama est conçu pour aider les ingénieurs logiciels de nombreux secteurs : recherche, industrie, projets open source, ONG, entreprises, etc.
- Il reste davantage de cas d’usage que ce que les modèles de base et Instruct peuvent offrir
- Meta espère que Code Llama incitera d’autres personnes à utiliser Llama 2 pour créer de nouveaux outils destinés à la recherche et aux produits commerciaux
- Ressources associées
1 commentaires
Commentaires de Hacker News
Fonctionne presque immédiatement avec llama.cpp, donc facile à tester en local : https://github.com/ggerganov/llama.cpp/issues/2766
En lançant CodeLlama-7b-Python avec une quantification q4_0, pour le prompt Python « affiche les 10 premiers nombres premiers », il génère un code plausible incluant
print_primes,is_primeetmainIl sera intéressant de voir ce que donneront les modèles plus grands, surtout après du tuning par la communauté et avec de meilleurs contextes/prompts
Dans
primes_upto(limit: int), on marque les nombres composés avec un tableau de booléens, puis avecitertools.isliceon n’affiche que les 10 premiers, ce qui donne2 3 5 7 11 13 17 19 23 29print("1, 2, 3, 5, 7, 11... and so on!Llama2 est sorti il y a plus d’un mois, mais cela fait des semaines que j’attends l’accès, et comme ce modèle passe par le même formulaire, je n’en attends pas grand-chose
Je me demande s’ils l’ont reçu par un autre moyen
Bien sûr, c’est presque une question de définition, et il peut exister des communautés ou des domaines où 1 est considéré comme premier, mais ce genre de subtilité apparaît quand on utilise des modèles de langage
¹) https://www.google.com/search?q=is+1+a+prime+number
Pour moi, le point clé est qu’il offre une génération stable avec un contexte allant jusqu’à 100 000 tokens
Tous les modèles ont été entraînés sur des séquences de 16 000 tokens, et il est indiqué qu’ils montrent des améliorations même avec des entrées allant jusqu’à 100 000 tokens
Cela dit, en lisant l’article, la précision de récupération des informations clés se dégrade fortement au-delà de 16k tokens, donc il reste à voir à quel point un contexte de 100k sera réellement utile
L’article mentionne Unnatural Code Llama, qui domine les autres modèles/fine-tunings sur tous les benchmarks, sauf lorsqu’il perd de peu face à Code Llama Python sur MBPP pass@100 et de peu face à GPT-4 sur HumanEval pass@1
Meta se contente de dire qu’ils ne publieront pas ce modèle plus tard, sans explication, donc je me demande pourquoi ils ne sortent pas un modèle qui a l’air aussi impressionnant
Utiliser simplement des couches Transformer d’une largeur de 100k serait probablement impossible en coût, alors quel tour de passe-passe ont-ils utilisé ?
Même le modèle 7B de Code Llama semble compétitif avec Codex, le modèle derrière Copilot
https://ai.meta.com/blog/code-llama-large-language-model-cod...
GitHub a aussi indiqué à plusieurs reprises qu’ils se dirigeaient vers GPT-4 avec « Copilot X »[1][2]
[0] https://github.blog/2023-07-28-smarter-more-efficient-coding...
[1] https://github.com/features/preview/copilot-x
[2] https://github.blog/2023-07-20-github-copilot-chat-beta-now-...
Je garde 7B ouvert en permanence dans un onglet de terminal pendant que je code, pour les questions du genre « comment faire ce truc au hasard ? », et pour moi il a presque remplacé Google/Stack Overflow
Code Llama Python est particulièrement intéressant, car il est spécifiquement tuné pour Python
Je me demande s’il serait possible de créer des LLM spécialisés — un modèle très bon en Rust en général, un autre en Linux en général, un autre en génomique, un autre en modélisation physique — puis de les faire dialoguer entre eux pour résoudre les problèmes en collaboration
Ce serait un avenir assez fou, où l’on fait vraiment travailler les machines
Cela dit, il est plus probable qu’il utilise quelques gros modèles plutôt qu’un grand nombre de petits modèles
Il y a quelques mois, une tentative similaire a été faite pour les scripts Godot, et elle est réputée plutôt bonne : https://github.com/minosvasilias/godot-dodo
À mon avis, s’il n’y a pas eu plus de tentatives, c’est parce que Llama de base n’était pas très bon en code par rapport à ses autres points forts, et que des modèles comme Starcoder sont relativement passés inaperçus
Si vous ne connaissez pas encore, cherchez Society of Mind
C est suffisamment bas niveau tout en restant lisible dans de rares moments
Le meilleur modèle, Unnatural Code Llama, n’a pas été publié
C’est sans doute très probablement parce qu’il a été entraîné sur des données basées sur GPT-4, ce qui pourrait enfreindre les conditions d’utilisation d’OpenAI
D’après l’article « Unnatural »[1], les données « unnatural » sont générées avec l’aide d’un LLM, et on voudrait sans doute utiliser le meilleur LLM possible
[1] https://arxiv.org/pdf/2212.09689.pdf
TheBloke, ce n’est pas de la blague[1]
Des versions quantifiées devraient arriver dans la journée, et j’ai très hâte d’essayer un modèle 34B Python quantifié en 4 bits qui devrait rentrer pile dans une 3090
[1] https://huggingface.co/TheBloke/CodeLlama-13B-Python-fp16
ollama run codellama:7b-instructhttps://ollama.ai/blog/run-code-llama-locally
D’autres modèles sont encore en cours d’ajout : https://ollama.ai/library/codellama
Pour faire tourner Code Llama en local, on peut télécharger et exécuter la version quantifiée à 7B paramètres avec l’outil open source Ollama : https://github.com/jmorganca/ollama
ollama run codellama "write a python function to add two numbers"Le modèle de complétion, le modèle Python et davantage de modèles avec différents nombres de paramètres devraient bientôt être ajoutés
Une fenêtre de contexte de 100 000 tokens, ce n’est pas mal, mais je me demande quel contexte choisira un modèle de code intégré lorsqu’il devra traiter une base de code de plus de 100K tokens
Je me demande aussi si, en codant en sachant que ces outils vont se généraliser et qu’on en dépendra davantage, il y aura de nouvelles choses à prendre en compte
Faut-il mettre plus ou moins de commentaires, écrire du code plus court et moins lisible pour consommer moins de tokens, modifier la structure des fichiers ou les conventions de nommage ? En fin de compte, je me demande comment nous devrons nous adapter pour tirer le meilleur parti de ces outils
On peut rendre le code indépendant du contexte et le réduire pour utiliser moins de tokens, mais cela le rend plus confus à la fois pour les humains et pour les modèles de langage
À l’extrême, si on n’utilise que des fonctions et variables d’une seule lettre comme
i,j,k, le modèle ne pourra rien inférer et produira des absurdités arbitrairesLa solution consiste à faire comme on le fait déjà pour gérer la complexité : découper les gros travaux en petits modules boîte noire et en API, de façon à cacher les implémentations gourmandes en tokens et à les rendre non pertinentes pour l’usage
Si l’on donne au LLM la signature d’une fonction, une bonne description et quelques exemples d’utilisation, il peut utiliser cette fonction sans connaître son implémentation
La concision ne fait que réduire la capacité du LLM à traiter le code ; elle ne résout pas le problème de longueur de contexte et, même dans le meilleur des cas, elle ne passe pas à l’échelle
100k tokens, c’est largement suffisant, donc il n’y a pas besoin de faire ce genre de choses
Ces informations peuvent être compressées dans un format pratique à présenter à un LLM
Par exemple, pour générer l’implémentation d’une méthode dans une classe C++, on peut donner au LLM une version compressée du fichier d’en-tête que le compilateur verrait lors de la compilation de cette classe
En supprimant les espaces et les commentaires, et en réduisant les macros, on peut économiser beaucoup de tokens
Les en-têtes de la bibliothèque standard sont probablement bien connus du LLM grâce au fine-tuning, donc on peut peut-être les omettre
Un fichier C++ prétraité classique peut atteindre la limite de 100K même après une certaine optimisation ; il faut donc absolument un middleware qui fasse un nettoyage supplémentaire avant de le passer au LLM
Le modèle produit de meilleurs raisonnements et de meilleures suggestions
C’est similaire pour les données : des données correctement étiquetées et des noms de champs descriptifs rendent les réponses du LLM beaucoup plus utiles
J’espère secrètement que la diffusion de ces outils poussera enfin mes collègues développeurs à commenter leur code et à arrêter d’utiliser des noms de variables de trois lettres
La manière de choisir quels fichiers fournir à GPT-4 reposait sur des embeddings
Je sélectionnais les fichiers qui semblaient les plus pertinents en combinant l’embedding de chaque fichier avec un traitement simple appliqué à l’embedding généré à partir de l’instruction
Ce n’était pas parfait, mais c’était largement suffisant pour des bases de code de taille moyenne, et pas adapté aux très grandes bases de code
À cause de cette implémentation, j’ai commencé à raccourcir mes fichiers et à déplacer du contenu vers d’autres fichiers
Les fichiers de plus de 1 000 lignes étaient pénibles parce qu’ils consommaient toute la fenêtre de contexte ; ce sera moins vrai avec une fenêtre de 100k, mais je pense qu’il vaut de toute façon mieux garder les fichiers courts
Il existe aussi des approches plus intelligentes, comme embedder des fonctions/classes individuelles plutôt que des fichiers entiers, donc quelqu’un fera bientôt quelque chose de meilleur
Il est très probable qu’il ne soit presque pas nécessaire de changer ses habitudes de codage pour exploiter l’IA
Fusionner du code réparti en un seul gros fichier, réduire les commentaires et supprimer les espaces, c’est quelque chose qu’un préprocesseur pour LLM peut faire
Copilot a bien fonctionné jusqu’ici, mais son interface est limitée
On dirait qu’il ne sait que prédire le prochain fragment de texte
Je me demande qui développe une IA de code capable de proposer des refactorings comme « ces lignes se répètent, il vaudrait mieux les extraire dans une fonction » ou « cette structure serait plus facile à utiliser si on la modifiait ainsi »
Sur Cody.dev, on peut créer des embeddings pour l’ensemble d’un dépôt, ce qui permet d’avoir un contexte beaucoup plus large sur la base de code et le problème à résoudre
À noter que j’ai rejoint Sourcegraph il y a quelques semaines
À mon avis, il n’y a encore rien de robuste
Il suffit de surligner le code et de faire une demande, et l’utilisation de Code Llama est aussi prise en charge : https://continue.dev/docs/walkthroughs/codellama
IntelliJ IDEA les propose déjà volontiers en local
Il peut repérer de gros blocs de code dupliqué et les refactorer automatiquement en fonction, et il existe aussi de nombreuses inspections qui proposent des refactorings pour rendre le code plus clair
La dernière fois que j’en ai entendu parler, c’était en bêta et ça ne fonctionnait pas très bien
Même sur la page d’exemples, le pinceau “add types” est trop strict parce que
aetbsont soumis à une vérificationnull, et “fix simple bug” ressemble plutôt à une correction de faute de frappeDu point de vue d’un parfait débutant qui n’a jamais fait tourner ce genre de modèle lui-même, je me demande quel matériel est nécessaire
Je n’ai pas vraiment trouvé l’information dans le README
L’idée de pouvoir utiliser ce type de modèle sans téléverser son code source vers une grande entreprise tech me plaît vraiment
Il suffit d’installer l’app et d’exécuter quelques commandes shell
Ce modèle sera probablement bientôt disponible lui aussi, et on devrait alors pouvoir l’utiliser avec l’extension Continue pour VS Code
C’est un peu lent, mais le swap semble être un substitut suffisant même sans disposer de la grande quantité de RAM requise
Ollama indique qu’il faut 32 Go pour exécuter le modèle 13B, mais je fais tourner le modèle
llama2:13bsur un MBP avec 16 GoLe 7B pourrait tourner même sur un grille-pain intelligent
Sinon, l’inférence CPU avec llama.cpp devrait fonctionner sur la plupart des machines