Aujourd'hui, nous sommes ravis de rendre open source la série de codeurs Qwen2.5 « puissants », « diversifiés » et « pratiques » (anciennement connue sous le nom de CodeQwen1.5), dédiée à la promotion continue du développement d'Open CodeLLM.
Puissant : Qwen2.5-Coder-32B-Instruct est devenu le modèle de code open source SOTA actuel, correspondant aux capacités de codage de GPT-4o. Tout en démontrant des capacités de codage solides et complètes, il possède également de bonnes compétences générales et mathématiques ;
Divers : S'appuyant sur les deux tailles précédemment open source de 1,5B/7B, cette version propose quatre tailles de modèle, dont 0,5B/3B/14B/32B. À partir de maintenant, Qwen2.5-Coder couvre six tailles de modèles grand public pour répondre aux besoins des différents développeurs ;
? Pratique : nous explorons le caractère pratique de Qwen2.5-Coder dans deux scénarios, y compris les assistants de code et les artefacts, avec quelques exemples illustrant les applications potentielles de Qwen2.5-Coder dans des scénarios du monde réel ;
Prise en charge de la compréhension et de la génération de contextes longs avec une longueur de contexte de 128 000 jetons ;
Prise en charge de 92 langages de codage ;
['ada', 'agda', 'alloy', 'antlr', 'applescript', 'assembly', 'augeas', 'awk', 'batchfile', 'bluespec', 'c', 'c#', 'c++', 'clojure', 'cmake', 'coffeescript', 'common-lisp', 'css', 'cuda', 'dart', 'dockerfile', 'elixir', 'elm', 'emacs-lisp', 'erlang', 'f#', 'fortran', 'glsl', 'go', 'groovy', 'haskell', 'html', 'idris', 'isabelle', 'java', 'java-server-pages', 'javascript', 'json', 'julia', 'jupyter-notebook', 'kotlin', 'lean', 'literate-agda', 'literate-coffeescript', 'literate-haskell', 'lua', 'makefile', 'maple', 'markdown', 'mathematica', 'matlab', 'objectc++', 'ocaml', 'pascal', 'perl', 'php', 'powershell', 'prolog', 'protocol-buffer', 'python', 'r', 'racket', 'restructuredtext', 'rmarkdown', 'ruby', 'rust', 'sas', 'scala', 'scheme', 'shell', 'smalltalk', 'solidity', 'sparql', 'sql', 'stan', 'standard-ml', 'stata', 'swift', 'systemverilog', 'tcl', 'tcsh', 'tex', 'thrift', 'typescript', 'verilog', 'vhdl', 'visual-basic', 'vue', 'xslt', 'yacc', 'yaml', 'zig']
Conserver les points forts en mathématiques et les capacités générales du modèle de base
Important
Nous mettons à jour les jetons spéciaux et leurs identifiants de jetons correspondants, afin de maintenir la cohérence avec Qwen2.5. Les nouveaux jetons spéciaux sont les suivants :
{ "<|fim_prefix|>": 151659,
"<|fim_middle|>": 151660,
"<|fim_suffix|>": 151661,
"<|fim_pad|>": 151662,
"<|repo_name|>": 151663,
"<|file_sep|>": 151664,
"<|im_start|>": 151644,
"<|im_end|>": 151645}| nom du modèle | taper | longueur | Télécharger |
|---|---|---|---|
| Qwen2.5-Codeur-0.5B | base | 32k | Visage câlin • ModelScope |
| Qwen2.5-Codeur-1.5B | base | 32k | Visage câlin • ModelScope |
| Qwen2.5-Coder-3B | base | 32k | Visage câlin • ModelScope |
| Qwen2.5-Coder-7B | base | 128k | Visage câlin • ModelScope |
| Qwen2.5-Coder-14B | base | 128k | Visage câlin • ModelScope |
| Qwen2.5-Coder-32B | base | 128k | Visage câlin • ModelScope |
| Qwen2.5-Coder-0.5B-instruction | instruire | 32k | Visage câlin • ModelScope |
| Qwen2.5-Coder-1.5B-instruction | instruire | 32k | Visage câlin • ModelScope |
| Qwen2.5-Coder-3B-instruction | instruire | 32k | Visage câlin • ModelScope |
| Qwen2.5-Coder-7B-instruction | instruire | 128k | Visage câlin • ModelScope |
| Qwen2.5-Coder-14B-instruction | instruire | 128k | Visage câlin • ModelScope |
| Qwen2.5-Coder-32B-instruction | instruire | 128k | Visage câlin • ModelScope |
| Qwen2.5-Coder-0.5B-Instruct-AWQ | instruire | 32k | Visage câlin • ModelScope |
| Qwen2.5-Coder-0.5B-Instruct-GGUF | instruire | 32k | Visage câlin • ModelScope |
| Qwen2.5-Coder-0.5B-Instruct-GPTQ-Int4 | instruire | 32k | Visage câlin • ModelScope |
| Qwen2.5-Coder-0.5B-Instruct-GPTQ-Int8 | instruire | 32k | Visage câlin • ModelScope |
| Qwen2.5-Coder-1.5B-Instruct-AWQ | instruire | 32k | Visage câlin • ModelScope |
| Qwen2.5-Coder-1.5B-Instruct-GGUF | instruire | 32k | Visage câlin • ModelScope |
| Qwen2.5-Coder-1.5B-Instruct-GPTQ-Int4 | instruire | 32k | Visage câlin • ModelScope |
| Qwen2.5-Coder-1.5B-Instruct-GPTQ-Int8 | instruire | 32k | Visage câlin • ModelScope |
| Qwen2.5-Coder-3B-Instruct-AWQ | instruire | 32k | Visage câlin • ModelScope |
| Qwen2.5-Coder-3B-Instruct-GGUF | instruire | 32k | Visage câlin • ModelScope |
| Qwen2.5-Coder-3B-Instruct-GPTQ-Int4 | instruire | 32k | Visage câlin • ModelScope |
| Qwen2.5-Coder-3B-Instruct-GPTQ-Int8 | instruire | 32k | Visage câlin • ModelScope |
| Qwen2.5-Coder-7B-Instruct-AWQ | instruire | 128k | Visage câlin • ModelScope |
| Qwen2.5-Coder-7B-Instruct-GGUF | instruire | 128k | Visage câlin • ModelScope |
| Qwen2.5-Coder-7B-Instruct-GPTQ-Int4 | instruire | 128k | Visage câlin • ModelScope |
| Qwen2.5-Coder-7B-Instruct-GPTQ-Int8 | instruire | 128k | Visage câlin • ModelScope |
| Qwen2.5-Coder-14B-Instruct-AWQ | instruire | 128k | Visage câlin • ModelScope |
| Qwen2.5-Coder-14B-Instruct-GGUF | instruire | 128k | Visage câlin • ModelScope |
| Qwen2.5-Coder-14B-Instruct-GPTQ-Int4 | instruire | 128k | Visage câlin • ModelScope |
| Qwen2.5-Coder-14B-Instruct-GPTQ-Int8 | instruire | 128k | Visage câlin • ModelScope |
| Qwen2.5-Coder-32B-Instruct-AWQ | instruire | 128k | Visage câlin • ModelScope |
| Qwen2.5-Coder-32B-Instruct-GGUF | instruire | 128k | Visage câlin • ModelScope |
| Qwen2.5-Coder-32B-Instruct-GPTQ-Int4 | instruire | 128k | Visage câlin • ModelScope |
| Qwen2.5-Coder-32B-Instruct-GPTQ-Int8 | instruire | 128k | Visage câlin • ModelScope |
Les performances détaillées et l'introduction sont présentées dans ce ? bloguer.
python>=3.9
transformers>4.37.0 pour les modèles denses Qwen2.5.
Avertissement
C'est un must car les « transformateurs » intègrent les codes Qwen2 depuis la « 4.37.0 ».
Vous pouvez installer les packages requis avec la commande suivante :
pip install -r exigences.txt
Important
Qwen2.5-Coder-[0.5-32]B-Instrcut sont des modèles d'instructions pour discuter ;
Qwen2.5-Coder-[0.5-32]B est un modèle de base généralement utilisé pour la complétion, servant de meilleur point de départ pour un réglage précis.
Vous pouvez simplement écrire plusieurs lignes de code avec transformers pour discuter avec Qwen2.5-Coder-32B-Instruct. Essentiellement, nous construisons le tokenizer et le modèle avec la méthode from_pretrained , et nous utilisons la méthode generate pour discuter à l'aide du modèle de discussion fourni par le tokenizer. Vous trouverez ci-dessous un exemple de discussion avec Qwen2.5-Coder-32B-Instruct :
à partir des transformateurs importent AutoModelForCausalLM, AutoTokenizermodel_name = "Qwen/Qwen2.5-Coder-32B-Instruct"model = AutoModelForCausalLM.from_pretrained(model_name,torch_dtype="auto",device_map="auto")tokenizer = AutoTokenizer.from_pretrained(model_name)prompt = "écrire un algorithme de tri rapide." messages = [
{"role": "system", "content": "Vous êtes Qwen, créé par Alibaba Cloud. Vous êtes un assistant utile."},
{"role": "utilisateur", "content": invite}
]text = tokenizer.apply_chat_template(messages,tokenize=False,add_generation_prompt=True)model_inputs = tokenizer([text], return_tensors="pt").to(model.device)generated_ids = model.generate(**model_inputs,max_new_tokens= 512)identifiants_générés = [output_ids[len(input_ids):] pour input_ids, output_ids dans zip(model_inputs.input_ids, generate_ids)
]response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0] La fonction apply_chat_template() est utilisée pour convertir les messages dans un format que le modèle peut comprendre. L'argument add_generation_prompt est utilisé pour ajouter une invite de génération, qui fait référence à <|im_start|>assistantn à l'entrée. Notamment, nous appliquons le modèle ChatML pour les modèles de discussion en suivant notre pratique précédente. L'argument max_new_tokens est utilisé pour définir la longueur maximale de la réponse. La fonction tokenizer.batch_decode() est utilisée pour décoder la réponse. En termes d'entrée, les messages ci-dessus sont un exemple pour montrer comment formater votre historique de dialogue et votre invite système. Vous pouvez utiliser l’autre taille du modèle d’instruction de la même manière.
Le modèle complète les extraits de code selon les invites données, sans aucun formatage supplémentaire, généralement appelé code completion dans les tâches de génération de code.
Essentiellement, nous construisons le tokenizer et le modèle avec la méthode from_pretrained , et nous utilisons la méthode generate pour effectuer la complétion du code. Vous trouverez ci-dessous un exemple sur la façon de discuter avec Qwen2.5-Coder-32B :
from transformers import AutoTokenizer, AutoModelForCausalLMdevice = "cuda" # le périphérique sur lequel charger le modèle# Vous n'avez plus besoin d'ajouter "trust_remote_code=True"TOKENIZER = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-Coder-32B")MODEL = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-Coder-32B", device_map="auto").eval()# tokeniser l'entrée dans tokensinput_text = "#écrire un algorithme de tri rapide"model_inputs = TOKENIZER([input_text], return_tensors ="pt").to(device)# Utilisez `max_new_tokens` pour contrôler la longueur maximale de sortie.generated_ids = MODEL.generate(model_inputs.input_ids, max_new_tokens=512, do_sample=False)[0]# Les identifiants générés incluent les prompt_ids, nous n'avons donc besoin de décoder les jetons qu'après prompt_ids.output_text = TOKENIZER.decode(generated_ids[len(model_inputs.input_ids [0]):], skip_special_tokens=True)print(f"Invite : {input_text}nnTexte généré : {output_text}") L'argument max_new_tokens est utilisé pour définir la longueur maximale de la réponse. Le input_text peut être n’importe quel texte avec lequel vous souhaitez que le modèle continue.
Le config.json actuel est défini pour une longueur de contexte allant jusqu'à 32 768 jetons. Pour gérer des entrées étendues dépassant 32 768 jetons, nous utilisons YaRN, une technique permettant d'améliorer l'extrapolation de la longueur du modèle, garantissant des performances optimales sur les textes longs.
Pour les frameworks pris en charge, vous pouvez ajouter les éléments suivants à config.json pour activer YaRN :
{...,
"rope_scaling": {"factor": 4.0, "original_max_position_embeddings": 32768, "type": "fil"
}
} La tâche d'insertion de code, également appelée défi « remplir le milieu », nécessite l'insertion de segments de code de manière à combler les lacunes dans un contexte de code donné. Pour une approche alignée sur les meilleures pratiques, nous vous recommandons de respecter les directives de formatage décrites dans le document « Formation efficace des modèles linguistiques pour remplir le milieu » [arxiv]. Cela implique l'utilisation de trois jetons spécialisés <fim_prefix> , <fim_suffix> et <fim_middle> pour désigner les segments respectifs de la structure du code. L'invite doit être structurée comme suit :
prompt = '<|fim_prefix|>' + préfixe_code + '<|fim_suffix|>' + suffixe_code + '<|fim_middle|>'
Suivant l’approche mentionnée, un exemple serait structuré de cette manière :
à partir des transformateurs importer AutoTokenizer, AutoModelForCausalLM# charger modeldevice = "cuda" # le périphérique sur lequel charger le modèle surTOKENIZER = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-Coder-32B")MODEL = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5 -Codeur-32B", device_map="auto").eval()input_text = """<|fim_prefix|>def quicksort(arr) : si len(arr) <= 1 : return arr pivot = arr[len(arr) // 2] < |fim_suffix|> middle = [x pour x dans arr si x == pivot] right = [x pour x dans arr si x > pivot] return tri rapide (gauche) + milieu + quicksort(right)<|fim_middle|>"""model_inputs = TOKENIZER([input_text], return_tensors="pt").to(device)# Utilisez `max_new_tokens` pour contrôler la longueur maximale de sortie.generated_ids = MODEL.generate(model_inputs .input_ids, max_new_tokens=512, do_sample=False)[0]# Les identifiants générés incluent les prompt_ids, nous n'avons besoin de décoder les jetons qu'après prompt_ids.output_text = TOKENIZER.decode(generated_ids[len(model_inputs.input_ids[0]):], skip_special_tokens=True)print(f "Invite : {input_text}nnTexte généré : {output_text}") La tâche de complétion de code au niveau du référentiel consiste à alimenter le modèle avec le contenu de plusieurs fichiers du même référentiel. Cela permet au modèle de comprendre les relations entre les différents appels au sein de ces fichiers, facilitant ainsi l'achèvement du contenu du code. Nous vous recommandons d'utiliser les deux jetons spéciaux <|repo_name|> et <|file_sep|> pour indiquer la structure du référentiel. Par exemple, en supposant que le nom du référentiel est stocké dans repo_name et qu'il contient des fichiers avec leurs chemins et contenus respectifs répertoriés comme [( file_path1 , file_content1 ), ( file_path2 , file_content2 )], le format de l'invite de saisie finale serait le suivant :
input_text = f'''<|repo_name|>{repo_name}<|file_sep|>{file_path1} {file_content1}<|file_sep|>{file_path2} {file_content2}''' from transformers import AutoTokenizer, AutoModelForCausalLMdevice = "cuda" # le périphérique sur lequel charger le modèle# Vous n'avez plus besoin d'ajouter "trust_remote_code=True"TOKENIZER = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-Coder-32B")MODEL = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-Coder-32B", device_map="auto").eval()# tokeniser l'entrée dans tokensinput_text = """<|repo_name|>library-system<|file_sep|>library .pyclass Livre : def __init__(self, titre, auteur, isbn, copies) : self.title = titre self.author = auteur self.isbn = isbn self.copies = copies def __str__(self): return f"Titre : {self.title}, Auteur : {self.author}, ISBN : {self.isbn}, Copies : {self.copies} "Bibliothèque de classe : def __init__(self) : self.books = [] def add_book(self, titre, auteur, isbn, copies) : book = Book(titre, auteur, isbn, copies) self.books.append(book) def find_book(self, isbn) : pour le livre dans self.books : si book.isbn == isbn : return book return Aucun def list_books(self) : return self.books<|file_sep|> student.pyclass Étudiant : def __init__(self, name, id) : self.name = nom self.id = id self.borrowed_books = [] def Borrowed_books.append(book) book.copies -= 1 return True return False def return_book(self, book, library) : si livre en soi .borrowed_books : self.borrowed_books.remove(book) book.copies += 1 return True return False<|file_sep|>main.pyfrom library import Libraryfrom student import Studentdef main(): # Configurer la bibliothèque avec quelques livres library = Library() library.add_book("The Great Gatsby", "F. Scott Fitzgerald", "1234567890", 3) library.add_book("To Kill a Mockingbird", "Harper Lee", "1234567891", 2) # Créer un étudiant student = Student("Alice", "S1") # L'élève emprunte un livre"""model_inputs = TOKENIZER([input_text], return_tensors="pt").to(device)# Utiliser `max_new_tokens` pour contrôler la longueur maximale de sortie.generated_ids = MODEL.generate(model_inputs.input_ids, max_new_tokens=1024, do_sample=False)[0]# Les id_générés incluent les prompt_ids, nous n'avons donc besoin de décoder les jetons qu'après prompt_ids.output_text = TOKENIZER.decode(generated_ids[len(model_inputs.input_ids[0]):], skip_special_tokens=True)print(f"Invite : n{input_text}nnTexte généré : n{output_text}")Le résultat attendu est le suivant :
Texte généré:book = library.find_book("1234567890")if student.borrow_book(book, library):print(f"{student.name} emprunté {book.title}")else:print(f"{student.name } n'a pas pu emprunter {book.title}") # L'étudiant renvoie un livre si student.return_book(book, library):print(f"{student.name} renvoyé {book.title}")else:print(f"{student.name} could not return {book.title}") # Liste tous les livres de la bibliothèqueprint("Tous les livres de la bibliothèque :")pour le livre de la bibliothèque. list_books():print(book)if __name__ == "__main__":main()En tant que membre de la famille Qwen2.5, Qwen2.5-Coder est pris en charge par vLLM. Le didacticiel détaillé se trouve dans le didacticiel Qwen. Ici, nous vous donnons un exemple simple d'inférence par lots hors ligne dans vLLM.
from transformers import AutoTokenizerfrom vllm import LLM, SamplingParams# Initialiser le tokenizertokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-Coder-32B")# Passer les hyperparamètres de décodage par défaut de Qwen1.5-32B-Chat# max_tokens est pour le maximum longueur pour la génération.sampling_params = SamplingParams(temperature=0.7, top_p=0.8, repetition_penalty=1.05, max_tokens=1024)# Saisissez le nom ou le chemin du modèle. Peut être des modèles GPTQ ou AWQ.llm = LLM(model="Qwen/Qwen2.5-Coder-32B")# Préparez vos invitesprompt = "#écrivez un algorithme de tri rapide.ndef quick_sort("# generate outputsoutputs = llm.generate( [prompt], sampling_params)# Imprimer la sortie outputs.for dans outputs:prompt = output.promptgenerated_text = output.outputs[0].textprint(f"Invite : {prompt!r}, Texte généré : {generated_text!r}") Pour augmenter les débits de vos services, le service distribué vous aide en exploitant davantage de périphériques GPU. Lorsque vous utilisez des séquences ultra longues pour l’inférence, cela peut entraîner une mémoire GPU insuffisante. Ici, nous montrons comment exécuter Qwen2.5-Coder-32B avec le parallélisme tensoriel simplement en passant l'argument tensor_parallel_size .
llm = LLM(model="Qwen/Qwen2.5-Coder-32B", tensor_parallel_size=8)
Nous fournissons également une interface Gradio pour une meilleure expérience, simplement gérée par :
cd demo/chatbot/# Pour les utilisateurs Linux et Windows (et macOS avec Intel ??)python app.py # Pour macOS avec les utilisateurs d'Apple Silicon, Intel n'est pas pris en charge, cela peut être 20 fois plus lent que RTX 4090PYTORCH_ENABLE_MPS_FALLBACK=1 python app.py
Nous fournissons également une interface Gradio du mode artefacts :
démo cd/artefacts/ application python.py
Vous pouvez spécifier les arguments --server_port , --share , --server_name pour satisfaire vos besoins !
Ou essayez-le sans effort sur HuggingFace : 「démo de chatbot」 ? 「démo d'artefacts」
Pour plus d'informations, veuillez vous référer au rapport technique Qwen2.5-Coder.
Si vous trouvez notre travail utile, n'hésitez pas à nous citer.
@article{hui2024qwen2, titre={Qwen2. Rapport technique 5-Coder}, auteur = {Hui, Binyuan et Yang, Jian et Cui, Zeyu et Yang, Jiaxi et Liu, Dayiheng et Zhang, Lei et Liu, Tianyu et Zhang, Jiajun et Yu, Bowen et Dang, Kai et other}, journal={arXiv preprint arXiv:2409.12186}, year={2024}}@article{qwen2,title={Qwen2 Technique Rapport},author={An Yang et Baosong Yang et Binyuan Hui et Bo Zheng et Bowen Yu et Chang Zhou et Chengpeng Li et Chengyuan Li et Dayiheng Liu et Fei Huang et Guanting Dong et Haoran Wei et Huan Lin et Jialong Tang et Jialin Wang et Jian Yang et Jianhong Tu et Jianwei Zhang et Jianxin Ma et Jin Xu et Jingren Zhou et Jinze Bai et Jinzheng He et Junyang Lin et Kai Dang et Keming Lu et Keqin Chen et Kexin Yang et Mei Li et Mingfeng Xue et Na Ni et Pei Zhang et Peng Wang et Ru Peng et Rui Men et Ruize Gao et Runji Lin et Shijie Wang et Shuai Bai et Sinan Tan et Tianhang Zhu et Tianhao Li et Tianyu Liu et Wenbin Ge et Xiaodong Deng et Xiaohuan Zhou et Xingzhang Ren et Xinyu Zhang et Xipin Wei et Xuancheng Ren et Yang Fan et Yang Yao et Yichang Zhang et Yu Wan et Yunfei Chu et Yuqiong Liu et Zeyu Cui et Zhenru Zhang et Zhihao Fan},journal={arXiv preprint arXiv:2407.10671},year={2024}}Si vous souhaitez laisser un message à notre équipe de recherche ou à notre équipe produit, rejoignez nos groupes Discord ou WeChat !
↑ Retour en haut ↑
