Tutoriel Mistral 7B: un guide étape par étape pour utiliser et affiner Mistral 7B

Ce tutoriel fournit un guide complet pour utiliser et affiner le modèle de langue Mistral 7B pour les tâches de traitement du langage naturel. Vous apprendrez à tirer parti de Kaggle pour l'accès au modèle, à effectuer une inférence, à appliquer des techniques de quantification, à affiner le modèle, à fusionner les adaptateurs et à se déployer sur le hub étreint.

Accès à Mistral 7B

Mistral 7B est accessible via diverses plates-formes, notamment le visage étreint, le sommet AI, la reproduction, le sagemaker Jumpstart et Baseten. Ce tutoriel se concentre sur l'utilisation de la fonctionnalité "modèles" de Kaggle pour l'accès rationalisé, éliminant le besoin de téléchargements manuels.

Cette section démontre le chargement du modèle de Kaggle et la référence. Les mises à jour essentielles de la bibliothèque sont cruciales pour éviter les erreurs:

<code>!pip install -q -U transformers
!pip install -q -U accelerate
!pip install -q -U bitsandbytes</code>

La quantification 4 bits avec la configuration de NF4 à l'aide de bitsandbytes améliore la vitesse de chargement et réduit l'utilisation de la mémoire:

<code>from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig, pipeline
import torch

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_use_double_quant=True,
)</code>

Ajouter le modèle Mistral 7B à votre ordinateur portable Kaggle implique ces étapes:

1. Cliquez sur "Ajouter des modèles" dans le panneau de droite.
2. Recherchez "Mistral 7B", sélectionnez "7B-V0.1-HF" et ajoutez-le.
3. Notez le chemin du répertoire.

Le chargement du modèle et du tokenizer utilise la bibliothèque transformers:

<code>model_name = "/kaggle/input/mistral/pytorch/7b-v0.1-hf/1"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
        model_name,
        load_in_4bit=True,
        quantization_config=bnb_config,
        torch_dtype=torch.bfloat16,
        device_map="auto",
        trust_remote_code=True,
    )</code>

L'inférence est simplifiée à l'aide de la fonction pipeline:

<code>pipe = pipeline(
    "text-generation", 
    model=model, 
    tokenizer = tokenizer, 
    torch_dtype=torch.bfloat16, 
    device_map="auto"
)</code>

Inciter le modèle et les paramètres de réglage:

<code>prompt = "As a data scientist, can you explain the concept of regularization in machine learning?"

sequences = pipe(
    prompt,
    do_sample=True,
    max_new_tokens=100, 
    temperature=0.7, 
    top_k=50, 
    top_p=0.95,
    num_return_sequences=1,
)
print(sequences[0]['generated_text'])</code>

Mistral 7B Fine-Tuning

Cette section vous guide à travers le Mistral 7B de réglage fin sur l'ensemble de données guanaco-llama2-1k, en utilisant des techniques comme PEFT, la quantification 4 bits et Qlora. Le tutoriel fait également référence à un guide sur le taure fin 2 pour un contexte supplémentaire.

Configuration

Les bibliothèques nécessaires sont installées:

<code>%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U peft
%pip install -U accelerate
%pip install -U trl</code>

Les modules pertinents sont importés:

<code>from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig,HfArgumentParser,TrainingArguments,pipeline, logging
from peft import LoraConfig, PeftModel, prepare_model_for_kbit_training, get_peft_model
import os,torch, wandb
from datasets import load_dataset
from trl import SFTTrainer</code>

Les clés API sont gérées en toute sécurité à l'aide de secrets Kaggle:

<code>from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()
secret_hf = user_secrets.get_secret("HUGGINGFACE_TOKEN")
secret_wandb = user_secrets.get_secret("wandb")</code>

Face et poids et biais étreintes sont configurés:

<code>!huggingface-cli login --token $secret_hf
wandb.login(key = secret_wandb)
run = wandb.init(
    project='Fine tuning mistral 7B', 
    job_type="training", 
    anonymous="allow"
)</code>

Le modèle de base, l'ensemble de données et le nouveau nom du modèle sont définis:

<code>base_model = "/kaggle/input/mistral/pytorch/7b-v0.1-hf/1"
dataset_name = "mlabonne/guanaco-llama2-1k"
new_model = "mistral_7b_guanaco"</code>

Chargement des données

L'ensemble de données est chargé et un échantillon s'affiche:

<code>dataset = load_dataset(dataset_name, split="train")
dataset["text"][100]</code>

Chargement Mistral 7B

Le modèle est chargé d'une précision 4 bits:

<code>bnb_config = BitsAndBytesConfig(  
    load_in_4bit= True,
    bnb_4bit_quant_type= "nf4",
    bnb_4bit_compute_dtype= torch.bfloat16,
    bnb_4bit_use_double_quant= False,
)
model = AutoModelForCausalLM.from_pretrained(
        base_model,
        load_in_4bit=True,
        quantization_config=bnb_config,
        torch_dtype=torch.bfloat16,
        device_map="auto",
        trust_remote_code=True,
)
model.config.use_cache = False
model.config.pretraining_tp = 1
model.gradient_checkpointing_enable()</code>

Chargement du tokenizer

Le tokenzer est chargé et configuré:

<code>tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
tokenizer.padding_side = 'right'
tokenizer.pad_token = tokenizer.eos_token
tokenizer.add_eos_token = True
tokenizer.add_bos_token, tokenizer.add_eos_token</code>

ajoutant l'adaptateur

Un adaptateur LORA est ajouté pour un réglage fin efficace:

<code>model = prepare_model_for_kbit_training(model)
peft_config = LoraConfig(
    lora_alpha=16,
    lora_dropout=0.1,
    r=64,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj","gate_proj"]
)
model = get_peft_model(model, peft_config)</code>

hyperparamètres

Les arguments de formation sont définis:

<code>training_arguments = TrainingArguments(
    output_,
    num_train_epochs=1,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=1,
    optim="paged_adamw_32bit",
    save_steps=25,
    logging_steps=25,
    learning_rate=2e-4,
    weight_decay=0.001,
    fp16=False,
    bf16=False,
    max_grad_norm=0.3,
    max_steps=-1,
    warmup_ratio=0.03,
    group_by_length=True,
    lr_scheduler_type="constant",
    report_to="wandb"
)</code>

Formation SFT

Le sfttrainer est configuré et la formation est lancée:

<code>!pip install -q -U transformers
!pip install -q -U accelerate
!pip install -q -U bitsandbytes</code>

Économiser et pousser le modèle

Le modèle affiné est sauvé et poussé vers le moyeu de face étreint:

<code>from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig, pipeline
import torch

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_use_double_quant=True,
)</code>

Évaluation du modèle

Les performances du modèle sont évaluées à l'aide de poids et de biais. Des exemples d'inférence sont fournis.

fusion de l'adaptateur

L'adaptateur est fusionné avec le modèle de base, et le modèle résultant est poussé vers le visage étreint.

Accès au modèle affiné

Le modèle fusionné est chargé de la face étreinte et l'inférence est démontrée.

Conclusion

Le didacticiel se termine par un résumé des capacités de Mistral 7B et un récapitulatif des étapes liées à l'accès, à l'affinement et au déploiement du modèle. Les ressources et les FAQ sont également incluses. L'accent est mis sur la fourniture d'un guide pratique pour que les utilisateurs travaillent avec ce puissant modèle de langue.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!