Guide complet de Zephyr-7B : fonctionnalités, utilisation et affinement

Tout le monde surveille le classement des LLM open source de Hugging Face et les nouveaux modèles ouverts qui visent des performances proches de GPT-4. L’un d’eux fait beaucoup parler de lui : Zephyr-7B.

Dans ce tutoriel, nous allons découvrir le modèle de langage Zephyr-7B. Nous y accéderons via la pipeline Transformers et l’affinerons sur un jeu de données Agent-Instruct.

Si vous débutez en intelligence artificielle, consultez le parcours de compétences AI Fundamentals. Il vous mettra sur les rails pour devenir l’ingénieur IA de demain.

Comprendre Zephyr-7B

Zephyr-7B est un modèle de langage de pointe développé par WebPilot.AI. Il fait partie de la série Zephyr, entraînée pour agir comme un assistant utile. Zephyr-7B est conçu pour exceller dans de nombreuses tâches linguistiques : génération de texte cohérent, traduction multilingue, synthèse d’informations, analyse de sentiment et réponses contextuelles aux questions.

Zephyr-7B-β

Zephyr-7B-β est le second modèle de la série. Il s’agit d’une version de Mistral-7B affinée sur une combinaison de jeux de données publics et synthétiques à l’aide de la Direct Preference Optimization (DPO). Résultat : Zephyr-7B-β sait aussi bien interpréter des questions complexes que résumer de longs passages de texte.

Au moment de sa sortie, Zephyr-7B-β est le modèle conversationnel 7B le mieux classé sur les benchmarks MT-Bench et AlpacaEval. Il s’appuie sur les dernières avancées en traitement du langage naturel pour atteindre un niveau inédit de compréhension et de génération de texte proche du langage humain.

Vous pouvez découvrir ses performances en testant la démo gratuite sur Zephyr Chat.

Image issue de Zephyr Chat

Accéder à Zephyr-7B

Comme dans le tutoriel Mistral 7B, nous allons charger et utiliser Zephyr-7B-beta avec transformers de Hugging Face. Rien de plus simple.

Remarque : si vous rencontrez des problèmes au chargement du modèle, consultez le notebook Kaggle d’inférence.

Commencez par installer les bibliothèques nécessaires. Assurez-vous d’utiliser la dernière version, sinon cela ne fonctionnera pas.

!pip install -q -U transformers\n!pip install -q -U accelerate\n!pip install -q -U bitsandbytes

Chargez ensuite PyTorch et le module pipeline de Transformers.

import torch\nfrom transformers import pipeline

Nous allons construire la pipeline de génération de texte en précisant le nom du modèle, les arguments torch_dtype et device_map.

La valeur \« auto\ » de device_map permet d’exploiter plusieurs GPU pour accélérer la génération.

Le type torch.bfloat16 (brain float) est un format flottant 16 bits avec le même exposant que torch.float32 mais une mantisse réduite. Il accélère les calculs et réduit l’usage mémoire, au prix d’une précision inférieure.

model_name = \"HuggingFaceH4/zephyr-7b-beta\"\n\npipe = pipeline(\n    \"text-generation\",\n    model=model_name,\n    torch_dtype=torch.bfloat16,\n    device_map=\"auto\",\n)

Il suffit ensuite de fournir le prompt et les autres arguments nécessaires à l’objet pipeline et d’afficher la réponse.

prompt = \"Write a Python function that can clean the HTML tags from the file:\"\n\noutputs = pipe(\n    prompt,\n    max_new_tokens=300,\n    do_sample=True,\n    temperature=0.7,\n    top_k=50,\n    top_p=0.95,\n)\nprint(outputs[0][\"generated_text\"])

La réponse est plus qu’impressionnante : le code Python est fourni avec des commentaires.

Nous pouvons même personnaliser la réponse du modèle en fournissant un prompt système au format Zephyr-7B.

Nous allons utiliser la fonction pipe.tokenizer.apply_chat_template pour créer un prompt à partir d’une liste de dictionnaires. Ces dictionnaires décrivent le rôle et le comportement de l’assistant, ainsi que le prompt utilisateur.

messages = [\n    {\n        \"role\": \"system\",\n        \"content\": \"You are a skilled software engineer who consistently produces high-quality Python code.\",\n    },\n    {\n        \"role\": \"user\",\n        \"content\": \"Write a Python code to display text in a star pattern.\",\n    },\n]\n\nprompt = pipe.tokenizer.apply_chat_template(\n    messages, tokenize=False, add_generation_prompt=True\n)

Enfin, nous passons le prompt à la pipeline avec les paramètres de génération pour obtenir la réponse.

outputs = pipe(\n    prompt,\n    max_new_tokens=300,\n    do_sample=True,\n    temperature=0.7,\n    top_k=50,\n    top_p=0.95,\n)\nprint(outputs[0][\"generated_text\"])\n

Zephyr-7B propose une solution très optimisée, accompagnée d’explications et de la sortie de la fonction. Bluffant. C’est un excellent outil pour générer du code Python.

Affiner Zephyr-7B

Dans cette section, nous allons voir comment affiner le modèle Zephyr-7B-beta sur un jeu de données personnalisé en utilisant les GPU gratuits de Kaggle. En suivant les étapes, vous pourrez préparer votre modèle pour la mise en production en à peine deux heures.

Remarque : si vous rencontrez des problèmes lors de l’entraînement, consultez le notebook Kaggle de fine-tuning.

Mise en place

Commencez par installer les bibliothèques Python nécessaires pour charger le jeu de données et le modèle, puis les affiner.

%%capture\n%pip install -U bitsandbytes\n%pip install -U transformers\n%pip install -U peft\n%pip install -U accelerate\n%pip install -U trl

Nous chargerons ensuite les modules utiles qui simplifient le travail et permettent d’entraîner le modèle avec une mémoire limitée.

from transformers import (\n    AutoModelForCausalLM,\n    AutoTokenizer,\n    BitsAndBytesConfig,\n    HfArgumentParser,\n    TrainingArguments,\n    pipeline,\n    logging,\n)\nfrom peft import (\n    LoraConfig,\n    PeftModel,\n    prepare_model_for_kbit_training,\n    get_peft_model,\n)\nimport os, torch, wandb\nfrom datasets import load_dataset\nfrom trl import SFTTrainer

Cette partie est spécifique aux notebooks Kaggle. Nous avons ajouté les clés API pour Hugging Face et Weights & Biases (wandb) dans les secrets Kaggle. Nous les utiliserons en toute sécurité pour publier le modèle sur Hugging Face Hub et suivre l’entraînement en direct sur le serveur Weights & Biases.

from kaggle_secrets import UserSecretsClient\nuser_secrets = UserSecretsClient()\nsecret_hf = user_secrets.get_secret(\"HUGGINGFACE_TOKEN\")\nsecret_wandb = user_secrets.get_secret(\"wandb\")

Connectez-vous à Hugging Face via la CLI avec votre clé API.

!huggingface-cli login --token $secret_hf

Faites de même avec wandb et initialisez le projet.

# Monitoring the LLM\nwandb.login(key = secret_wandb)\nrun = wandb.init(\n    project='Fine tuning Zephyr 7B', \n    job_type=\"training\", \n    anonymous=\"allow\"\n)

Indiquez les noms du modèle de base, du jeu de données et du nouveau modèle pour l’affinage, l’enregistrement et la publication sur Hugging Face Hub.

base_model = \"HuggingFaceH4/zephyr-7b-beta\"\ndataset_name = \"THUDM/AgentInstruct\"\nnew_model = \"zephyr-7b-beta-Agent-Instruct\"

Jeu de données AgentInstruct

Nous allons charger le jeu de données puis le convertir au style de prompts Zephyr-7B grâce à la fonction format_prompt. Elle extrait le rôle et le contenu, puis les convertit en longues chaînes commençant par un prompt système et se terminant par une instruction par défaut.

#Importing the dataset\ndataset = load_dataset(\"THUDM/AgentInstruct\", split=\"train\")\ndef format_prompt(sample):\n    intro = \"Below is a conversation between a user and you.\"\n    end = \"Instruction: Write a response appropriate to the conversation.\"\n\n    try:\n        formatted_conversations = \"\\n\".join(\n            f\"<{resp['from']}>: {resp['value']}\"\n            for resp in sample[\"conversations\"]\n        )\n\n        sample[\"text\"] = f\"{intro}\\n\\n{formatted_conversations}\\n\\n{end}\"\n    except (TypeError, KeyError):\n        raise ValueError(\"Invalid format of the input sample.\")\n    return sample\n\n\n\ndataset = dataset.map(\n    format_prompt,\n    remove_columns=[\"conversations\"]\n)\ndataset[\"text\"][100]

Chargement du modèle et du tokenizer

Nous allons télécharger et charger un modèle en précision 4 bits depuis Hugging Face pour accélérer l’entraînement. C’est indispensable quand les GPU disposent de peu de VRAM. Nous chargerons ensuite le tokenizer et le configurerons pour corriger le problème lié au fp16.

bnb_config = BitsAndBytesConfig(  \n    load_in_4bit= True,\n    bnb_4bit_quant_type= \"nf4\",\n    bnb_4bit_compute_dtype= torch.bfloat16,\n    bnb_4bit_use_double_quant= False,\n)\nmodel = AutoModelForCausalLM.from_pretrained(\n        base_model,\n        load_in_4bit=True,\n        quantization_config=bnb_config,\n        torch_dtype=torch.bfloat16,\n        device_map=\"auto\",\n        trust_remote_code=True,\n)\nmodel.config.use_cache = False\nmodel.config.pretraining_tp = 1\nmodel.gradient_checkpointing_enable()\n\n# Load tokenizer\ntokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)\ntokenizer.padding_side = 'right'\ntokenizer.pad_token = tokenizer.eos_token\ntokenizer.add_eos_token = True\ntokenizer.add_bos_token, tokenizer.add_eos_token

Construction du modèle

Nous allons maintenant ajouter une couche d’adaptation (adapter) à notre modèle pour l’affiner plus efficacement. Plutôt que de réentraîner tout le modèle, nous ne mettrons à jour que les paramètres de cette couche pour un entraînement plus rapide.

model = prepare_model_for_kbit_training(model)\npeft_config = LoraConfig(\n    lora_alpha=16,\n    lora_dropout=0.1,\n    r=64,\n    bias=\"none\",\n    task_type=\"CAUSAL_LM\",\n    target_modules=['up_proj', 'base_layer', 'down_proj']\n)\nmodel = get_peft_model(model, peft_config)

Entraîner le modèle

Il est essentiel de définir correctement les hyperparamètres dans les arguments d’entraînement. Vous pouvez en apprendre davantage dans le tutoriel affiner LLaMA 2.

Nous allons ensuite utiliser la bibliothèque TRL de Hugging Face pour construire le SFT Trainer avec les composants nécessaires : modèle, jeu de données, configuration LoRA, tokenizer et paramètres d’entraînement.

Enfin, nous lançons l’entraînement.

#Hyperparamter\ntraining_arguments = TrainingArguments(\n    output_dir=\"./results\",\n    num_train_epochs=1,\n    per_device_train_batch_size=4,\n    gradient_accumulation_steps=1,\n    optim=\"paged_adamw_32bit\",\n    save_steps=25,\n    logging_steps=25,\n    learning_rate=2e-4,\n    weight_decay=0.001,\n    fp16=False,\n    bf16=False,\n    max_grad_norm=0.3,\n    max_steps=-1,\n    warmup_ratio=0.03,\n    group_by_length=True,\n    lr_scheduler_type=\"constant\",\n    report_to=\"wandb\"\n)\n\n\n# Setting sft parameters\ntrainer = SFTTrainer(\n    model=model,\n    train_dataset=dataset,\n    peft_config=peft_config,\n    max_seq_length= 512,\n    dataset_text_field=\"text\",\n    tokenizer=tokenizer,\n    args=training_arguments,\n    packing= False,\n)\n\n\ntrainer.train()

Après environ 1 h 40, l’entraînement s’est terminé et nous avons observé une baisse progressive de la perte d’entraînement.

Voici une évaluation plus détaillée issue de Weights & Biases.

Nous allons maintenant enregistrer le modèle, clore la session wandb et pousser le modèle sur Hugging Face Hub. Cela créera un dépôt de modèle avec le fichier d’adapter enregistré.

# Save the fine-tuned model\ntrainer.model.save_pretrained(new_model)\nwandb.finish()\n\ntrainer.model.push_to_hub(new_model, use_temp_dir=False)

Voici le dépôt du modèle affiné, accessible via : hf.co/kingabzpro/zephyr-7b-beta-Agent-Instruct

Il est temps de tester notre modèle affiné sur différents prompts.

Nous avons demandé à notre modèle comment utiliser Python en ligne avec DataCamp.

logging.set_verbosity(logging.CRITICAL)\n\nprompt = \"How to use Python online with DataCamp?\"\npipe = pipeline(task=\"text-generation\", model=model, tokenizer=tokenizer, max_length=200)\nresult = pipe(prompt)\nprint(result[0]['generated_text'])

On constate que la réponse ressemble à celle d’AgentGPT, un agent IA autonome capable d’enchaîner des tâches via des extensions et d’atteindre des résultats proches de systèmes IA avancés. Ces systèmes peuvent, par exemple, rechercher sur le web, mettre à jour du code et le tester.

Plutôt que de demander une liste d’instructions, posons une question simple sur un parcours de carrière DataCamp.

prompt = \"What is Datacamp Career track?\"\nresult = pipe(prompt)\nprint(result[0]['generated_text'])

Nous avons bien reçu une réponse, qui a entraîné un enchaînement de questions-réponses (pas toujours exactes), ce qui est intriguant.

La prochaine étape de votre parcours consiste à utiliser ce modèle pour créer votre application IA. Pour cela, des outils adaptés vous feront gagner du temps. Voici une sélection de 7 outils essentiels de génération IA pour concevoir des applications d’IA de haut niveau.

Conclusion

Le grand modèle de langage Zephyr-7B-beta a montré une remarquable capacité de compréhension et de réponse précise. Dans ce tutoriel, nous avons présenté Zephyr-7B et vu comment y accéder via la pipeline Transformers. Nous avons aussi appris à l’affiner sur un jeu de données d’agents, ce qui lui confère une meilleure capacité de raisonnement et des réponses de type instruction, proches d’AgentGPT.

Ce guide s’adresse à tous les passionnés de machine learning qui souhaitent expérimenter et affiner de grands modèles de langage sur des GPU à mémoire limitée.

Inscrivez-vous au cours Master Large Language Models (LLMs) Concepts pour comprendre les briques des LLM, leurs méthodes d’entraînement et des techniques similaires à celles de Zephyr-7B.