Uitgebreide gids voor Zephyr-7B: functies, gebruik en fine-tuning

Iedereen houdt de OpenAI LLM Leaderboard in de gaten en de nieuwe open-sourcemodellen die mikken op GPT-4-prestaties. Eén model dat de laatste tijd veel buzz genereert, is Zephyr-7B.

In deze tutorial maken we kennis met een nieuw taalmodel, Zephyr-7B. We benaderen het via de Transformers-pijplijn en voeren fine-tuning uit op een Agent-Instruct-dataset.

Ben je nieuw in Artificial Intelligence? Bekijk dan het skill track AI Fundamentals. Dit bereidt je voor en zet je op weg om de AI-engineer van de toekomst te worden.

Zephyr-7B begrijpen

Zephyr-7B is een geavanceerd taalmodel ontwikkeld door WebPilot.AI. Het maakt deel uit van de Zephyr-serie taalmodellen die zijn getraind om als behulpzame assistenten te fungeren. Zephyr-7B is ontworpen om uit te blinken in allerlei taalgebaseerde taken, zoals het genereren van samenhangende tekst, vertalen tussen verschillende talen, het samenvatten van belangrijke informatie, sentimentanalyse en het beantwoorden van vragen op basis van context.

Zephyr-7B-β

Zephyr-7B-β is het tweede model in de serie. Het is een fijn-afgestemde versie van het Mistral-7B-model, getraind op een combinatie van publieke en synthetische datasets met behulp van Direct Preference Optimization (DPO). Daardoor toont Zephyr-7B-β capaciteiten die variëren van het interpreteren van complexe vragen tot het samenvatten van lange tekstpassages.

Ten tijde van de release is Zephyr-7B-β het hoogst gerankte 7B-chatmodel op de MT-Bench- en AlpacaEval-benchmarks. Het profiteert van de nieuwste ontwikkelingen in natural language processing en bereikt zo nieuwe hoogten in het begrijpen en genereren van mensachtige tekst.

Je kunt de verbeterde prestaties ervaren via de gratis demo op Zephyr Chat.

Afbeelding van Zephyr Chat

Toegang krijgen tot Zephyr-7B

Net als in de Mistral 7B-tutorial gaan we Zephyr-7B-beta laden en gebruiken via Hugging Face transformers. Dat is vrij eenvoudig.

Opmerking: als je problemen hebt met het laden van het model, bekijk dan het Inference Kaggle Notebook.

Installeer eerst alle benodigde libraries. Zorg dat je de nieuwste versie draait, anders werkt het niet.

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

Laad daarna de Pytorch-library en de pipeline-module uit transformers.

import torch
from transformers import pipeline

We bouwen de tekstgeneratiepijplijn met de argumenten voor modelnaam, torch_dtype en device_map.

De “auto” in device_map betekent dat meerdere GPU's gebruikt kunnen worden om sneller een reactie te genereren.

De torch.bfloat16 (brain float) is een 16-bits floating-pointdatatype met dezelfde exponentgrootte als torch.float32 maar een kleinere mantisse. Dit zorgt voor snellere berekening en lager geheugengebruik, maar ook voor lagere precisie en nauwkeurigheid.

model_name = "HuggingFaceH4/zephyr-7b-beta"

pipe = pipeline(
    "text-generation",
    model=model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

We moeten de prompt en andere vereiste argumenten aan het pipeline-object meegeven en de respons printen.

prompt = "Write a Python function that can clean the HTML tags from the file:"

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

De respons is meer dan indrukwekkend. Het levert de Python-code met commentaar.

We kunnen de modelrespons zelfs aanpassen door de systeemprompt in Zephyr-7B-stijl mee te geven.

We gebruiken de functie pipe.tokenizer.apply_chat_template om een prompt te maken op basis van een lijst met dictionaries. De dictionaries bevatten informatie over de rol en het gedrag van de chatassistent en de prompt van de gebruiker.

messages = [
    {
        "role": "system",
        "content": "You are a skilled software engineer who consistently produces high-quality Python code.",
    },
    {
        "role": "user",
        "content": "Write a Python code to display text in a star pattern.",
    },
]

prompt = pipe.tokenizer.apply_chat_template(
    messages, tokenize=False, add_generation_prompt=True
)

Tot slot geven we de prompt en extra argumenten aan het pipeline-object door om de respons te genereren.

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

De Zephyr-7B kwam met de meest geoptimaliseerde oplossing, inclusief uitleg en de uitvoer van de functie. Dit is geweldig. Mensen zouden het moeten gebruiken om Python-code te genereren.

Zephyr-7B fijn afstellen

In dit onderdeel leren we hoe je het Zephyr-7B-beta-model fijnstemt op een aangepaste dataset met behulp van de gratis GPU's van Kaggle. Volg de instructies en je kunt je model binnen twee uur voorbereiden op productie.

Opmerking: als je problemen hebt met het trainen van het model, bekijk dan het Fine-tuning Kaggle Notebook.

Instellen

Installeer eerst de benodigde Python-libraries om de dataset en het model te laden en te fijnstemmen.

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

Vervolgens laden we de benodigde modules die het leven makkelijker maken en helpen om het model met beperkt geheugen te trainen.

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

Dit onderdeel is specifiek voor Kaggle-notebooks. We hebben de API-sleutels voor Hugging Face en Weights & Biases (wandb) toegevoegd aan Kaggle secrets. We gebruiken ze veilig om het model te uploaden naar de Hugging Face Hub en het trainingstraject live te monitoren op de server van Weights and Biases.

from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()
secret_hf = user_secrets.get_secret("HUGGINGFACE_TOKEN")
secret_wandb = user_secrets.get_secret("wandb")

Log in bij Hugging Face via de CLI en API-sleutel.

!huggingface-cli login --token $secret_hf

Log op vergelijkbare wijze in bij wandb en start het project.

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

Geef de namen op van het basismodel, de dataset en het nieuwe model voor fine-tuning, opslaan en pushen naar de Hugging Face Hub.

base_model = "HuggingFaceH4/zephyr-7b-beta"
dataset_name = "THUDM/AgentInstruct"
new_model = "zephyr-7b-beta-Agent-Instruct"

AgentInstruct-dataset

We laden de dataset en zetten die vervolgens om naar Zephyr-7B-promptstijl met de functie format_prompt. De functie haalt de rol en inhoud uit de dataset en zet die om naar lange strings die beginnen met een systeemprompt en eindigen met een standaardinstructie.

#Importing the dataset
dataset = load_dataset("THUDM/AgentInstruct", split="train")
def format_prompt(sample):
    intro = "Below is a conversation between a user and you."
    end = "Instruction: Write a response appropriate to the conversation."

    try:
        formatted_conversations = "\n".join(
            f"<{resp['from']}>: {resp['value']}"
            for resp in sample["conversations"]
        )

        sample["text"] = f"{intro}\n\n{formatted_conversations}\n\n{end}"
    except (TypeError, KeyError):
        raise ValueError("Invalid format of the input sample.")
    return sample


dataset = dataset.map(
    format_prompt,
    remove_columns=["conversations"]
)
dataset["text"][100]

Het model en de tokenizer laden

We downloaden en laden een 4-bit-precisiemodel van Hugging Face om sneller te kunnen trainen. Dit is nodig om te kunnen fijnstemmen op GPU's met beperkte VRAM. Daarna laden we de tokenizer en configureren die om het probleem met fp16 te verhelpen.

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()

# Load tokenizer
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

Het model opbouwen

We voegen nu een adapterlaag toe aan ons model, zodat we het efficiënter kunnen fijnstemmen. In plaats van het hele model te finetunen, updaten we alleen de parameters in de adapterlaag voor snellere training.

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=['up_proj', 'base_layer', 'down_proj']
)
model = get_peft_model(model, peft_config)

Het model trainen

Het is belangrijk om de juiste hyperparameters in de trainingsargumenten te zetten. Je kunt over elk ervan lezen in de tutorial Fine-Tuning LLaMA 2.

Daarna gebruiken we HuggingFaces TRL-library om de SFT-trainer op te zetten met de benodigde componenten, zoals model, dataset, Lora-configuratie, tokenizer en trainingsparameters.

Tot slot starten we de training.

#Hyperparamter
training_arguments = TrainingArguments(
    output_dir="./results",
    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"
)


# Setting sft parameters
trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    peft_config=peft_config,
    max_seq_length= 512,
    dataset_text_field="text",
    tokenizer=tokenizer,
    args=training_arguments,
    packing= False,
)


trainer.train()

Na bijna 1 uur en 40 minuten was de training klaar en zagen we een geleidelijke daling van de training loss.

Hier is een meer gedetailleerde modelevaluatie van Weights & Biases.

We slaan nu het model op, sluiten de wandb-instantie af en pushen het model naar de Hugging Face Hub. Dit maakt een modelrepository met een opgeslagen adapterbestand.

# Save the fine-tuned model
trainer.model.save_pretrained(new_model)
wandb.finish()

trainer.model.push_to_hub(new_model, use_temp_dir=False)

Hier is de repository van het fijngestemde model die je kunt benaderen via: hf.co/kingabzpro/zephyr-7b-beta-Agent-Instruct

Het is tijd om ons fijngestemde model op verschillende prompts te testen.

We vroegen ons model hoe je Python online gebruikt met DataCamp.

logging.set_verbosity(logging.CRITICAL)

prompt = "How to use Python online with DataCamp?"
pipe = pipeline(task="text-generation", model=model, tokenizer=tokenizer, max_length=200)
result = pipe(prompt)
print(result[0]['generated_text'])

We zien dat de respons vergelijkbaar is met die van AgentGPT, een automatische AI-agent die meerdere taken uitvoert met diverse extensies en resultaten behaalt die vergelijkbaar zijn met geavanceerde AI-systemen. Deze systemen kunnen taken uitvoeren die lijken op die van mensen, zoals zoeken op het web, code updaten en testen.

In plaats van om stappenlijsten te vragen, stellen we ons model een eenvoudige vraag over de DataCamp career track.

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

We kregen een antwoord, maar het leidde tot meer vragen en antwoorden (waarvan niet allemaal juist zijn), wat intrigerend is.

De volgende stap in je reis is dit model gebruiken om je AI-applicatie te bouwen. Daarvoor heb je tools nodig die het je makkelijker maken. Hier is een lijst met 7 essentiële generatieve AI-tools die je helpen om eersteklas AI-toepassingen te bouwen.

Conclusie

Het grote taalmodel Zephyr-7B-beta toont een verbluffend vermogen om te begrijpen en accurate reacties te geven. In deze tutorial leerden we over Zephyr-7B en hoe je er toegang toe krijgt via de Transformers-pijplijn. We leerden ook hoe je het fijnstemt op een aangepaste Agent-dataset, wat het extra redeneervermogen geeft en instructiestijlantwoorden oplevert die lijken op AgentGPT.

Deze gids is een uitgebreide bron voor machinelearningliefhebbers van elk niveau die willen experimenteren met en fine-tunen van grote taalmodellen op GPU's met beperkt geheugen.

Schrijf je in voor de cursus Master Large Language Models (LLMs) Concepts om te leren over de bouwstenen, trainingsmethoden en technieken van LLM's zoals Zephyr-7B.