Llama 3.2 feinjustieren und lokal nutzen: Eine Schritt-für-Schritt-Anleitung

In letzter Zeit hat sich das Feld der großen Sprachmodelle (LLMs) schnell verändert. Neuere LLMs sind kleiner und intelligenter, was sie im Vergleich zu den größeren Modellen billiger und einfacher zu bedienen macht. 

Mit der Veröffentlichung von Llama 3.2 haben wir jetzt Zugang zu kleineren Modellen, wie den Varianten 1B und 3B. Auch wenn diese kleineren Modelle bei allgemeinen Aufgaben nicht die Genauigkeit größerer Modelle erreichen, können sie so fein abgestimmt werden, dass sie in bestimmten Bereichen, wie z. B. der Klassifizierung von Emotionen bei Kundeninteraktionen, außergewöhnlich gut abschneiden. Diese Fähigkeit ermöglicht es ihnen, traditionelle Modelle in diesen Bereichen zu ersetzen.

In diesem Tutorial werden wir die Möglichkeiten von Llama 3.2 Vision und Lightweight-Modellen erkunden. Wir werden lernen, wie wir auf das Llama 3.2 3B Modell zugreifen, es an einem Datensatz zur Kundenbetreuung feinabstimmen und es anschließend zusammenführen und in den Hugging Face Hub exportieren. Am Ende werden wir das Modell in das GGUF-Format konvertieren und es lokal mit der Jan-Anwendung verwenden.

Wenn du neu im Bereich der Künstlichen Intelligenz bist, ist es sehr empfehlenswert, dass du die KI-Grundlagen Lernpfad zu besuchen, um die Grundlagen von chatGPT, großen Sprachmodellen, generativer KI und mehr zu lernen.

Bild vom Autor

Wir stellen vor: Llama 3.2

Die Familie der Llama 3.2 Open-Source-Modelle hat zwei Varianten: die Lightweight- und die Vision-Modelle . Die Bildverarbeitungsmodelle zeichnen sich durch die Verknüpfung von Bild und Sprache aus, während die leichtgewichtigen Modelle gut in der mehrsprachigen Texterstellung und dem Aufruf von Tools für Edge Devices sind.

Leichte Modelle

Das leichte Modell hat zwei kleinere Varianten: 1B und 3B. Diese Modelle sind gut für die mehrsprachige Texterstellung und den Aufruf von Werkzeugen geeignet. Sie sind klein, so dass sie auf einem Gerät laufen können, um sicherzustellen, dass die Daten das Gerät nie verlassen, und bieten eine schnelle Texterstellung bei geringen Rechenkosten.

Um diese effizienten, leichtgewichtigen Modelle zu erstellen, verwendet Llama 3.2 Pruning- und Wissensdestillationstechniken. Durch Pruning wird die Größe des Modells bei gleichbleibender Leistung reduziert, und bei der Wissensdestillation werden größere Netzwerke genutzt, um Wissen mit kleineren zu teilen und so deren Leistung zu verbessern.

Das 3B-Modell übertrifft andere Modelle wie Gemma 2 (2.6B) und Phi 3.5-mini bei Aufgaben wie dem Befolgen von Anweisungen, dem Zusammenfassen, dem Umschreiben von Aufforderungen und der Verwendung von Hilfsmitteln.

Quelle: Llama 3.2: Revolutionierung von Edge AI und Vision mit offenen, anpassbaren Modellen

Vision Modelle

Die Vision-Modelle gibt es in zwei Varianten: 11B und 90B. Diese Modelle sind so konzipiert, dass sie das Image Reasoning unterstützen. Die 11B und 90B können Dokumente, Diagramme und Grafiken verstehen und interpretieren und Aufgaben wie Bildunterschriften und visuelle Erdung durchführen. Diese fortschrittlichen Sehfähigkeiten wurden durch die Integration von vortrainierten Bildkodierern mit Sprachmodellen ermöglicht, die aus Kreuzaufmerksamkeitsschichten bestehende Adaptergewichte verwenden.

Verglichen mit Claude 3 Haiku und GPT-4o minihaben die Llama 3.2-Vision-Modelle bei der Bilderkennung und verschiedenen visuellen Verstehensaufgaben brilliert, was sie zu robusten Werkzeugen für multimodale KI-Anwendungen macht.

Quelle: Llama 3.2: Revolutionierung von Edge AI und Vision mit offenen, anpassbaren Modellen

Du kannst mehr über Llama 3.2 Anwendungsfälle, Benchmarks, Llama Guard 3 und die Modellarchitektur erfahren, indem du unseren neuesten Blog liest, Llama 3.2 Guide: Funktionsweise, Anwendungsfälle und mehr.

Zugriff auf die Llama 3.2 Lightweight Modelle in Kaggle

Auch wenn das Llama 3.2-Modell frei verfügbar und quelloffen ist, musst du die Geschäftsbedingungen akzeptieren und das Formular auf der Website ausfüllen. 

Um Zugang zum neuesten Llama 3.2-Modell auf der Kaggle-Plattform zu erhalten:

1. Besuchen Sie die llama.com Website und fülle das Formular mit deinen Daten aus. Wähle sowohl leichte als auch visionäre Modelle. 

Quelle: Llama herunterladen

2. Gehe zum Meta | Llama 3.2 Modellseite und klicke auf die Schaltfläche "Formular einreichen".

Quelle: Meta | Llama 3.2 | Kaggle

3. Akzeptiere alle Bedingungen und drücke auf die Schaltfläche "Abschicken". 

Quelle: Meta | Llama 3.2 | Kaggle

4. Warte ein paar Minuten, bis du die Option siehst, das neue Notizbuch entweder herunterzuladen oder zu erstellen. Wähle die Registerkarte Transformers und die Modellvariante und klicke dann auf die Schaltfläche "+ Neues Notebook".

5. Das Kaggle-Notebook wird mit dem neuesten Llama-Modell eingeführt. Damit das funktioniert, müssen wir nur den Beschleuniger in "GPU T4 x2" ändern.

6. Aktualisiere die Python-Pakete Transformers und Accelerate. 

%%capture
%pip install -U transformers accelerateBereitgestellt von

7. Lade den Tokenizer und das Modell mit dem Transformers-Paket. Anstatt den Link zum Hugging Face Modell-Repository anzugeben, geben wir das lokale Verzeichnis an, in dem sich unser Modell befindet.

from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline, TextStreamer
import torch


base_model = "/kaggle/input/llama-3.2/transformers/3b-instruct/1"

tokenizer = AutoTokenizer.from_pretrained(base_model)

model = AutoModelForCausalLM.from_pretrained(
    base_model,
    return_dict=True,
    low_cpu_mem_usage=True,
    torch_dtype=torch.float16,
    device_map="auto",
    trust_remote_code=True,
)Bereitgestellt von

8. Stelle pad_token_id ein, um keine Warnmeldungen zu erhalten.

if tokenizer.pad_token_id is None:
    tokenizer.pad_token_id = tokenizer.eos_token_id
if model.config.pad_token_id is None:
    model.config.pad_token_id = model.config.eos_token_idBereitgestellt von

9. Erstelle die Textgenerierungspipeline mit Modell und Tokenizer. 

pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    torch_dtype=torch.float16,
    device_map="auto",
)Bereitgestellt von

10. Führe die Pipeline mit der benutzerdefinierten Eingabeaufforderung aus. In unserem Fall geht es um Vincent van Gogh.

messages = [{"role": "user", "content": "Who is Vincent van Gogh?"}]

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

outputs = pipe(prompt, max_new_tokens=120, do_sample=True)

print(outputs[0]["generated_text"])Bereitgestellt von

Die Antwort ist ziemlich genau. 

11. Wir geben dem System Anweisungen, um zu sehen, ob es komplexe Aufforderungen verstehen und befolgen kann. Wir werden die Ergebnisse als HTML anzeigen, indem wir den Markdown-Code einbinden. 

from IPython.display import Markdown, display

messages = [
    {
        "role": "system",
        "content": "You are a skilled Python developer specializing in database management and optimization.",
    },
    {
        "role": "user",
        "content": "I'm experiencing a sorting issue in my database. Could you please provide Python code to help resolve this problem?",
    },
]

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

outputs = pipe(prompt, max_new_tokens=512, do_sample=True)

display(
    Markdown(
            outputs[0]["generated_text"].split(
                "<|start_header_id|>assistant<|end_header_id|>"
            )[1]
        )
    )Bereitgestellt von

Das Ergebnis ist sehr genau. Das Modell schneidet trotz seiner nur 3 Milliarden Parameter ziemlich gut ab.

Wenn du Schwierigkeiten hast, auf die Llama 3.2 Leichtgewichtsmodelle zuzugreifen, schaue bitte im Notebook nach, Zugriff auf die Llama 3.2 Leichtgewichtsmodelle.

Zugriff auf die Llama 3.2 Vision Modelle in Kaggle

Der Zugriff auf das Vision-Modell ist einfach, und du musst dir keine Gedanken über den GPU-Speicher machen, da wir in diesem Leitfaden mehrere GPUs verwenden werden. 

1. Sende das Formular auf der Seite Meta | Llama 3.2 Vision Modellseite ein. Akzeptiere alle Bedingungen und klicke auf die Schaltfläche "Abschicken". 

Quelle: Meta | Llama 3.2 Vision | Kaggle

2. Scrolle nach unten, wähle die Registerkarte Transformer und die Modellvariante Vision und klicke dann auf "+ Neues Notebook".

Quelle: Meta | Llama 3.2 Vision | Kaggle

3. Stelle sicher, dass du "GPU T4 x2" als Beschleuniger verwendest. 
4. Aktualisiere die Python-Pakete Transformers und Accelerate.

%%capture
%pip install -U transformers accelerateBereitgestellt von

5. Lade den Bildprozessor und das Llama 3.2 Vision Model. 

import torch
from transformers import MllamaForConditionalGeneration, AutoProcessor

base_model = "/kaggle/input/llama-3.2-vision/transformers/11b-vision-instruct/1"

processor = AutoProcessor.from_pretrained(base_model)

model = MllamaForConditionalGeneration.from_pretrained(
    base_model,
    low_cpu_mem_usage=True,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)Bereitgestellt von

Wie wir sehen können, werden fast 25 GB GPU-Speicher verwendet. Auf einem Laptop oder der kostenlosen Version von Google Colab wird das nicht möglich sein.

6. Lade das Bild. Wir haben es mit dem Bild aus dem Tutorial versehen: OpenAI o1-preview Tutorial: Aufbau eines Machine Learning Projekts.
7. Schreibe die Nachricht und wandle sie mit einer Chat-Vorlage in einen Prompt um. Schreibe die Nachricht und wandle sie mit einer Chat-Vorlage in einen Prompt um. 
8. Verarbeite sowohl das Bild als auch den Text und gib ihn an das Modell weiter, um die Antwort zu generieren. 

import requests
from PIL import Image

url = "https://media.datacamp.com/cms/google/ad_4nxcz-j3ir2begccslzay07rqfj5ttakp2emttn0x6nkygls5ywl0unospj2s0-mrwpdtmqjl1fagh6pvkkjekqey_kwzl6qnodf143yt66znq0epflvx6clfoqw41oeoymhpz6qrlb5ajer4aeniogbmtwtd.png"
image = Image.open(requests.get(url, stream=True).raw)

messages = [
    {"role": "user", "content": [
        {"type": "image"},
        {"type": "text", "text": "Describe the tutorial feature image."}
    ]}
]
input_text = processor.apply_chat_template(messages, add_generation_prompt=True)
inputs = processor(image, input_text, return_tensors="pt").to(model.device)

output = model.generate(**inputs, max_new_tokens=120)
print(processor.decode(output[0]))Bereitgestellt von

Als Ergebnis erhalten wir eine detaillierte Beschreibung des Bildes. Das ist ziemlich genau. 

Wenn du beim Ausführen des obigen Codes auf Probleme stößt, lies bitte die Zugriff auf die Llama 3.2 Vision Modelle Kaggle Notizbuch.

Feinabstimmung Llama 3.2 3B Instruct

In diesem Abschnitt lernst du, wie du das Llama 3.2 3B Instruct Modell mit Hilfe der Transformers Bibliothek an den Kundenbetreuungsdatensatz anpassen kannst. Wir werden Kaggle nutzen, um auf freie GPUs zuzugreifen und mehr RAM als Colab zu bekommen. 

1. Einrichten

Starte das neue Notizbuch auf Kaggle und setze die Umgebungsvariablen. Wir werden die Hugging Face API nutzen, um das Modell zu speichern, und Weights & Biases, um seine Leistung zu verfolgen.

Installiere und aktualisiere alle notwendigen Python-Pakete. 

%%capture
%pip install -U transformers 
%pip install -U datasets 
%pip install -U accelerate 
%pip install -U peft 
%pip install -U trl 
%pip install -U bitsandbytes 
%pip install -U wandbBereitgestellt von

Lade die Python-Pakete und -Funktionen, die wir bei der Feinabstimmung und Auswertung verwenden werden.

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, setup_chat_formatBereitgestellt von

Melde dich mit deinem API-Schlüssel bei Hugging Face CLI an. 

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()

hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")
login(token = hf_token)Bereitgestellt von

Melde dich mit deinem API-Schlüssel bei Weights & Biases an und richte das neue Projekt ein. 

wb_token = user_secrets.get_secret("wandb")

wandb.login(key=wb_token)
run = wandb.init(
    project='Fine-tune Llama 3.2 on Customer Support Dataset', 
    job_type="training", 
    anonymous="allow"
)Bereitgestellt von

Setze die Variablen für den Basismodus, den Datensatz und den neuen Modellnamen. Wir werden sie in diesem Projekt an mehreren Stellen verwenden, daher ist es besser, sie zu Beginn festzulegen, um Verwirrung zu vermeiden.

base_model = "/kaggle/input/llama-3.2/transformers/3b-instruct/1"
new_model = "llama-3.2-3b-it-Ecommerce-ChatBot"
dataset_name = "bitext/Bitext-customer-support-llm-chatbot-training-dataset"Bereitgestellt von

2. Laden des Modells und des Tokenizers

Lege den Datentyp und die Aufmerksamkeitsimplementierung fest.

# Set torch dtype and attention implementation
if torch.cuda.get_device_capability()[0] >= 8:
    !pip install -qqq flash-attn
    torch_dtype = torch.bfloat16
    attn_implementation = "flash_attention_2"
else:
    torch_dtype = torch.float16
    attn_implementation = "eager"Bereitgestellt von

Lade das Modell und den Tokenizer, indem du das lokale Modellverzeichnis angibst. Auch wenn unser Modell klein ist, wird das Laden des vollständigen Modells und die Feinabstimmung einige Zeit in Anspruch nehmen. Stattdessen werden wir das Modell in 4-Bit-Quantisierung laden.

# QLoRA config
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch_dtype,
    bnb_4bit_use_double_quant=True,
)
# Load model
model = AutoModelForCausalLM.from_pretrained(
    base_model,
    quantization_config=bnb_config,
    device_map="auto",
    attn_implementation=attn_implementation
)

# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)Bereitgestellt von

3. Laden und Verarbeiten des Datensatzes

Wir laden den Bitext-Kunden-Support-llm-Chatbot Datensatz aus dem Hugging Face Hub. Es handelt sich um einen hybriden synthetischen Datensatz, den wir verwenden werden, um unseren eigenen Chatbot für den Kundensupport zu erstellen.

Wir werden nur 1000 Proben laden, mischen und auswählen. Wir stimmen das Modell auf einer kleinen Teilmenge ab, um die Trainingszeit zu verkürzen, aber du kannst jederzeit das vollständige Modell auswählen.

Als Nächstes erstellen wir die Spalte "Text" anhand der Systemanweisungen, der Benutzerabfragen und der Antworten des Assistenten. Dann wandeln wir die JSON-Antwort in das Chat-Format um.

#Importing the dataset
dataset = load_dataset(dataset_name, split="train")
dataset = dataset.shuffle(seed=65).select(range(1000)) # Only use 1000 samples for quick demo
instruction = """You are a top-rated customer service agent named John. 
    Be polite to customers and answer all their questions.
    """
def format_chat_template(row):
    
    row_json = [{"role": "system", "content": instruction },
               {"role": "user", "content": row["instruction"]},
               {"role": "assistant", "content": row["response"]}]
    
    row["text"] = tokenizer.apply_chat_template(row_json, tokenize=False)
    return row

dataset = dataset.map(
    format_chat_template,
    num_proc= 4,
)
Bereitgestellt von

Wie wir sehen können, haben wir die Kundenanfrage und die Antwort des Assistenten in einem Chatformat kombiniert. 

dataset['text'][3]Bereitgestellt von

4. Einrichten des Modells

Extrahiere den Namen des linearen Modells aus dem Modell. 

import bitsandbytes as bnb

def find_all_linear_names(model):
    cls = bnb.nn.Linear4bit
    lora_module_names = set()
    for name, module in model.named_modules():
        if isinstance(module, cls):
            names = name.split('.')
            lora_module_names.add(names[0] if len(names) == 1 else names[-1])
    if 'lm_head' in lora_module_names:  # needed for 16 bit
        lora_module_names.remove('lm_head')
    return list(lora_module_names)

modules = find_all_linear_names(model)Bereitgestellt von

Verwende den linearen Modulnamen, um den LoRA-Adapter zu erstellen. Wir werden nur den LoRA-Adopter feinjustieren und den Rest des Modells stehen lassen, um Speicherplatz zu sparen und die Trainingszeit zu verkürzen. 

# LoRA config
peft_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=modules
)
model, tokenizer = setup_chat_format(model, tokenizer)
model = get_peft_model(model, peft_config)Bereitgestellt von

Wir konfigurieren die Hyperparameter des Modells, um es in der Kaggle-Umgebung laufen zu lassen. Du kannst jeden Hyperparameter verstehen, indem du dich auf die Feineinstellung von Llama 2 Tutorial nachlesen und sie ändern, um das Training auf deinem System zu optimieren.

#Hyperparamter
training_arguments = TrainingArguments(
    output_dir=new_model,
    per_device_train_batch_size=1,
    per_device_eval_batch_size=1,
    gradient_accumulation_steps=2,
    optim="paged_adamw_32bit",
    num_train_epochs=1,
    eval_strategy="steps",
    eval_steps=0.2,
    logging_steps=1,
    warmup_steps=10,
    logging_strategy="steps",
    learning_rate=2e-4,
    fp16=False,
    bf16=False,
    group_by_length=True,
    report_to="wandb"
)Bereitgestellt von

Wir werden nun einen Supervised Fine-Tuning (SFT)-Trainer einrichten und einen Trainings- und Evaluierungsdatensatz, eine LoRA-Konfiguration, ein Trainingsargument, einen Tokenizer und ein Modell bereitstellen. 

# Setting sft parameters
trainer = SFTTrainer(
    model=model,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
    peft_config=peft_config,
    max_seq_length= 512,
    dataset_text_field="text",
    tokenizer=tokenizer,
    args=training_arguments,
    packing= False,
)Bereitgestellt von

5. Model Ausbildung

Starte den Trainingsprozess und überwache die Trainings- und Validierungsverluste. 

trainer.train()Bereitgestellt von

Der Trainingsverlust verringerte sich allmählich. Das ist ein gutes Zeichen. 

Die detaillierte Laufhistorie wird erstellt, wenn wir den Lauf "Gewichte & Verzerrungen" beenden. 

wandb.finish()Bereitgestellt von

Du kannst jederzeit das Dashboard Gewichte & Verzerrungen besuchen, um die Modellmetriken gründlich zu überprüfen.

6. Modell Inferenz

Um das fein abgestimmte Modell zu testen, werden wir es mit dem Beispielprompt aus dem Datensatz versehen. 

messages = [{"role": "system", "content": instruction},
    {"role": "user", "content": "I bought the same item twice, cancel order {{Order Number}}"}]

prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
    
inputs = tokenizer(prompt, return_tensors='pt', padding=True, truncation=True).to("cuda")

outputs = model.generate(**inputs, max_new_tokens=150, num_return_sequences=1)

text = tokenizer.decode(outputs[0], skip_special_tokens=True)

print(text.split("assistant")[1])Bereitgestellt von

Das fein abgestimmte Modell hat den Stil übernommen und eine genaue Antwort gegeben.

7. Speichern des Tokenizers und des Modells

Speichere das feinabgestimmte Modell lokal und schiebe es auch zum Hugging Face Hub. Die Funktion push_to_hub erstellt ein neues Modell-Repository und überträgt die Modelldateien in dein Hugging Face-Repository. 

# Save the fine-tuned model
trainer.model.save_pretrained(new_model)
trainer.model.push_to_hub(new_model, use_temp_dir=False)Bereitgestellt von

Quelle: kingabzpro/llama-3.2-3b-it-Ecommerce-ChatBot

Für die Feinabstimmung der größeren Llama 3-Modelle solltest du dir Folgendes ansehen Feinabstimmung von Llama 3.1 für die Textklassifikation Tutorial. Dieses Tutorial ist sehr beliebt und wird dir helfen, die LLMs zur kompletten Aufgabe zu finden. 

8. Speichern des Notizbuchs

Klicke auf die Schaltfläche "Version speichern" oben rechts, wähle die Option "Schnell speichern" und ändere die Option "Ausgabe speichern", um die Modelldatei und den gesamten Code zu speichern.

Schau dir die Feinabstimmung von Llama 3.2 auf Customer Support Kaggle-Notizbuch für den Quellcode, die Ergebnisse und die Ausgabe.

Dies ist ein sehr codebasierter Leitfaden. Wenn du einen Leitfaden ohne oder mit wenig Code für die Feinabstimmung der LLMs suchst, schau dir den LlaMA-Factory WebUI Beginner's Guide an: Feinabstimmung der LLMs.

Zusammenführen und Exportieren von Feinabstimmungen Llama 3.2 

Wir erstellen ein neues Notebook und fügen das zuvor gespeicherte Notebook hinzu, um auf den feinabgestimmten LoRA-Adapter zuzugreifen und Speicherprobleme zu vermeiden. 

Stelle sicher, dass du auch das Basismodell "Llama 3.2 3B Instruct" hinzugefügt hast.

Installiere und aktualisiere alle notwendigen Python-Pakete. 

%%capture
%pip install -U bitsandbytes
%pip install transformers==4.44.2
%pip install -U accelerate
%pip install -U peft
%pip install -U trlBereitgestellt von

Melde dich bei Hugging Face CLI an, um das zusammengeführte Modell an den Hugging Face Hub zu senden. 

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()

hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")
login(token = hf_token)Bereitgestellt von

Gib den Standort für das Basismodell an und stimme LoRA ab. Wir verwenden sie, um das Basismodell zu laden und es mit dem Adapter zusammenzuführen.

# Model
base_model_url = "/kaggle/input/llama-3.2/transformers/3b-instruct/1"
new_model_url = "/kaggle/input/fine-tune-llama-3-2-on-customer-support/llama-3.2-3b-it-Ecommerce-ChatBot/"Bereitgestellt von

Lade den Tokenizer und das vollständige Modell. 

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, pipeline
from peft import PeftModel
import torch
from trl import setup_chat_format
# Reload tokenizer and model
tokenizer = AutoTokenizer.from_pretrained(base_model_url)

base_model_reload= AutoModelForCausalLM.from_pretrained(
    base_model_url,
    low_cpu_mem_usage=True,
    return_dict=True,
    torch_dtype=torch.float16,
    device_map="auto",
)Bereitgestellt von

Wende das Chat-Format auf das Modell und den Tokenizer an. Führe dann das Basismodell mit dem LoRA-Adapter zusammen.

# Merge adapter with base model
base_model_reload, tokenizer = setup_chat_format(base_model_reload, tokenizer)
model = PeftModel.from_pretrained(base_model_reload, new_model_url)

model = model.merge_and_unload()Bereitgestellt von

Um zu überprüfen, ob das Modell erfolgreich zusammengeführt wurde, gibst du ihm die Musteraufforderung und generierst die Umkehrung. 

instruction = """You are a top-rated customer service agent named John. 
    Be polite to customers and answer all their questions.
    """

messages = [{"role": "system", "content": instruction},
    {"role": "user", "content": "I have to see what payment payment modalities are accepted"}]

prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
    
inputs = tokenizer(prompt, return_tensors='pt', padding=True, truncation=True).to("cuda")

outputs = model.generate(**inputs, max_new_tokens=150, num_return_sequences=1)

text = tokenizer.decode(outputs[0], skip_special_tokens=True)

print(text.split("assistant")[1])Bereitgestellt von

Wie wir sehen können, funktioniert unser fein abgestimmtes Modell perfekt. 

Speichere den Tokenizer und das Modell lokal. 

new_model = "llama-3.2-3b-it-Ecommerce-ChatBot"

model.save_pretrained(new_model)
tokenizer.save_pretrained(new_model)Bereitgestellt von

Schiebe den Tokenizer und das zusammengeführte Modell in das Hugging Face Modell-Repository.

model.push_to_hub(new_model, use_temp_dir=False)
tokenizer.push_to_hub(new_model, use_temp_dir=False)Bereitgestellt von

Nach ein paar Minuten kannst du alle Modelldateien mit Metadaten in deinem Hugging Face-Repository einsehen.

Quelle: kingabzpro/llama-3.2-3b-it-Ecommerce-ChatBot

Du kannst dir den Quellcode auch in der Zusammenführen und Exportieren von fein abgestimmtem Llama 3.2 Kaggle-Notizbuch nachlesen, um mehr über das Zusammenführen und Hochladen deines Modells in den Hugging Face Hub zu erfahren.

Der nächste Schritt in diesem Projekt besteht darin, das vollständige Modell in das GGUF-Format zu konvertieren und es dann zu quantisieren. Danach kannst du sie lokal mit deiner Lieblings-Chat-App wie Jan, Msty oder GPT4ALL nutzen. Folge dem Feinabstimmung von Llama 3 und seine lokale Nutzung um zu erfahren, wie du alle LLM in das GGUF-Format konvertierst und lokal auf deinem Laptop verwendest.

Konvertieren des fusionierten Modells in das GGUF-Format

Um das fein abgestimmte Modell lokal zu verwenden, müssen wir es zunächst in das GGUF-Format umwandeln. Und warum? Denn dies ist ein llama.cpp-Format und wird von allen Desktop-Chatbot-Anwendungen akzeptiert. 

Die Umwandlung des zusammengeführten Modells in das Format llama.ccp ist ganz einfach. Alles, was wir tun müssen, ist, in den GGUF My Repo Hugging Face Hub. Melde dich mit deinem Hugging Face-Konto an. Tippe den Link zum Repository für das Feinabstimmungsmodell "kingabzpro/llama-3.2-3b-it-Ecommerce-ChatBot" ein und drücke auf die Schaltfläche "Senden". 

Quelle: GGUF Mein Repo

Innerhalb weniger Sekunden wird die quantisierte Version des Modells in einem neuen Hugging Face Repository erstellt. 

Source: kingabzpro/llama-3.2-3b-it-Ecommerce-ChatBot-Q4_K_M-GGUF

Klicke auf den Reiter "Dateien" und lade nur die GGUF-Datei herunter. 

Source: llama-3.2-3b-it-ecommerce-chatbot-q4_k_m.gguf

Lokales Feinabstimmungsmodell verwenden

Wir werden die Jan Chatbot-Anwendung, um unser fein abgestimmtes Modell lokal zu nutzen. Gehe auf die offizielle Website jan.ai, um die Anwendung herunterzuladen und zu installieren. 

Quelle: Jan

Klicke auf die Einstellung, wähle das Menü "Meine Modelle" und drücke die Schaltfläche "Modell importieren". Gib ihm dann das lokale Verzeichnis des Modells. 

Gehe zum Chat-Menü und wähle das Feinabstimmungsmodell, wie unten gezeigt.

Klicke auf die Registerkarte "Assistent" auf der rechten Seite und gib die Systemaufforderung ein.

Systemaufforderung: "Du bist ein erstklassiger Kundenbetreuer namens John. Sei höflich zu den Kunden und beantworte alle ihre Fragen."

Klicke auf den Reiter "Modell", direkt neben dem Reiter "Assistent" und ändere das Stopp-Token in "<|eot_id|>"

Das war's. Alles, was du tun musst, ist, den KI-Kundenservice über dein Problem zu informieren. 

Prompt: "Wie bestelle ich mehrere Artikel beim selben Anbieter?"

Die Antwort war genau und superschnell - fast 102 Token pro Sekunde.

Fazit

Durch die Feinabstimmung der kleineren LLMs können wir Kosten sparen und die Inferenzzeit verbessern. Mit genügend Daten kannst du die Leistung des Modells bei bestimmten Aufgaben ähnlich wie beim GPT-4-mini verbessern. Kurz gesagt, die Zukunft der KI besteht darin, mehrere kleinere LLMs in einem Netz mit einer Master-Slave-Beziehung einzusetzen. 

Das Mastermodell empfängt die erste Aufforderung und entscheidet, welches spezialisierte Modell zur Erstellung der Antworten verwendet werden soll. Das reduziert die Rechenzeit, verbessert die Ergebnisse und senkt die laufenden Kosten.

In diesem Tutorial haben wir Llama 3.2 kennengelernt und erfahren, wie man in Kaggle darauf zugreift. Wir haben auch gelernt, das leichtgewichtige Llama 3.2 Modell auf den Kundensupport-Datensatz abzustimmen, damit es lernt, in einem bestimmten Stil zu antworten und genaue domänenspezifische Informationen zu liefern. Dann haben wir den LoRA-Adapter mit dem Basismodell zusammengeführt und das vollständige Modell an den Hugging Face Hub übertragen. Schließlich konvertierten wir das zusammengeführte Modell in das GGUF-Format und verwendeten es lokal auf dem Laptop mit der Jan-Chatbot-Anwendung.

Nimm unser Arbeiten mit Hugging Face interaktiven Kurs, um mehr über die Verwendung des Werkzeugs und die Feinabstimmung der Modelle zu erfahren.