Im Gemma Cookbook-Repository finden Sie Beispiele für die Generierung und Feinabstimmung. Weitere Informationen

Diese Seite wurde von der Cloud Translation API übersetzt.

Gemma mit Hugging Face Transformers und QloRA optimieren

In dieser Anleitung erfahren Sie, wie Sie Gemma mithilfe der Transformer von Hugging Face und TRL für einen benutzerdefinierten Text-zu-SQL-Datensatz optimieren. Informationen in diesem Dokument:

Was ist Quantized Low-Rank Adaptation (QLoRA)?
Entwicklungsumgebung einrichten
Dataset für die Feinabstimmung erstellen und vorbereiten
Gemma mit TRL und dem SFTTrainer optimieren
Modellinferenz testen und SQL-Abfragen generieren

Was ist Quantized Low-Rank Adaptation (QLoRA)?

In diesem Leitfaden wird die Verwendung von Quantized Low-Rank Adaptation (QLoRA) veranschaulicht. Diese Methode hat sich als beliebte Methode zur effizienten Feinabstimmung von LLMs etabliert, da sie die Anforderungen an die Rechenressourcen reduziert und gleichzeitig eine hohe Leistung beibehält. In QloRA wird das vortrainierte Modell auf 4 Bit quantisiert und die Gewichte werden eingefroren. Anschließend werden trainierbare Adapterschichten (LoRA) angehängt und nur die Adapterschichten werden trainiert. Anschließend können die Adaptergewichte mit dem Basismodell zusammengeführt oder als separater Adapter beibehalten werden.

Entwicklungsumgebung einrichten

Im ersten Schritt müssen Sie Hugging Face-Bibliotheken, einschließlich TRL, und Datasets installieren, um das offene Modell zu optimieren, einschließlich verschiedener RLHF- und ‑Ausrichtungstechniken.

# Install Pytorch & other libraries
%pip install "torch>=2.4.0" tensorboard

# Install Gemma release branch from Hugging Face
%pip install "transformers>=4.51.3"

# Install Hugging Face libraries
%pip install  --upgrade \
  "datasets==3.3.2" \
  "accelerate==1.4.0" \
  "evaluate==0.4.3" \
  "bitsandbytes==0.45.3" \
  "trl==0.15.2" \
  "peft==0.14.0" \
  protobuf \
  sentencepiece

# COMMENT IN: if you are running on a GPU that supports BF16 data type and flash attn, such as NVIDIA L4 or NVIDIA A100
#% pip install flash-attn

Hinweis: Wenn Sie eine GPU mit Ampere-Architektur (z. B. NVIDIA L4) oder höher verwenden, können Sie die Funktion „Flash-Aufmerksamkeit“ verwenden. Flash Attention ist eine Methode, die die Berechnungen erheblich beschleunigt und die Speichernutzung von quadratisch auf linear in der Sequenzlänge reduziert. Dadurch wird das Training um bis zu dreimal beschleunigt. Weitere Informationen finden Sie unter FlashAttention.

Bevor Sie mit dem Training beginnen können, müssen Sie die Nutzungsbedingungen für Gemma akzeptieren. Sie können die Lizenz bei Hugging Face akzeptieren, indem Sie auf der Modellseite unter http://huggingface.co/google/gemma-3-1b-pt auf die Schaltfläche „Zustimmen und auf Repository zugreifen“ klicken.

Nachdem Sie die Lizenz akzeptiert haben, benötigen Sie ein gültiges Hugging Face-Token, um auf das Modell zuzugreifen. Wenn Sie in einem Google Colab-Notebook arbeiten, können Sie Ihr Hugging Face-Token mit den Colab-Secrets sicher verwenden. Andernfalls können Sie das Token direkt in der Methode login festlegen. Achten Sie darauf, dass Ihr Token auch Schreibzugriff hat, da Sie Ihr Modell während des Trainings an den Hub senden.

from google.colab import userdata
from huggingface_hub import login

# Login into Hugging Face Hub
hf_token = userdata.get('HF_TOKEN') # If you are running inside a Google Colab
login(hf_token)

Dataset für die Feinabstimmung erstellen und vorbereiten

Bei der Feinabstimmung von LLMs ist es wichtig, den Anwendungsfall und die Aufgabe zu kennen, die Sie lösen möchten. So können Sie einen Datensatz erstellen, um Ihr Modell zu optimieren. Wenn Sie Ihren Anwendungsfall noch nicht definiert haben, sollten Sie noch einmal von vorn beginnen.

In dieser Anleitung liegt der Schwerpunkt auf dem folgenden Anwendungsfall:

Optimieren Sie ein Modell für die Umwandlung natürlicher Sprache in SQL für die nahtlose Integration in ein Datenanalysetool. Ziel ist es, den Zeitaufwand und das Fachwissen für die Erstellung von SQL-Abfragen erheblich zu reduzieren, damit auch Nutzer ohne technisches Vorwissen aussagekräftige Informationen aus Daten gewinnen können.

Text-zu-SQL kann ein guter Anwendungsfall für die Feinabstimmung von LLMs sein, da es sich um eine komplexe Aufgabe handelt, die viel (internes) Wissen über die Daten und die SQL-Sprache erfordert.

Sobald Sie festgestellt haben, dass eine Feinabstimmung die richtige Lösung ist, benötigen Sie einen Datensatz, den Sie optimieren können. Der Datensatz sollte eine vielfältige Reihe von Demonstrationen der Aufgaben enthalten, die Sie lösen möchten. Es gibt mehrere Möglichkeiten, einen solchen Datensatz zu erstellen:

Vorhandene Open-Source-Datasets wie Spider verwenden
Verwendung von synthetischen Datasets, die von LLMs wie Alpaca erstellt wurden
Verwendung von von Menschen erstellten Datasets wie Dolly.
Eine Kombination der Methoden verwenden, z. B. Orca

Jede Methode hat Vor- und Nachteile und hängt vom Budget, von der Zeit und von den Qualitätsanforderungen ab. Die Verwendung eines vorhandenen Datensatzes ist beispielsweise die einfachste Methode, aber möglicherweise nicht auf Ihren spezifischen Anwendungsfall zugeschnitten. Die Einbeziehung von Fachleuten aus der jeweiligen Branche ist zwar möglicherweise am genauesten, aber zeitaufwendig und teuer. Es ist auch möglich, mehrere Methoden zu kombinieren, um einen Anweisungsdatensatz zu erstellen, wie in Orca: Progressives Lernen aus komplexen Erklärungsspuren von GPT-4 gezeigt.

In diesem Leitfaden wird ein bereits vorhandener Datensatz (philschmid/gretel-synthetic-text-to-sql) verwendet, ein hochwertiger synthetischer Text-zu-SQL-Datensatz mit Anweisungen in natürlicher Sprache, Schemadefinitionen, Begründungen und der entsprechenden SQL-Abfrage.

Hugging Face TRL unterstützt die automatische Erstellung von Vorlagen für Konversationsdatensatzformate. Sie müssen also nur Ihren Datensatz in die richtigen JSON-Objekte konvertieren. trl kümmert sich um die Vorlage und das richtige Format.

{"messages": [{"role": "system", "content": "You are..."}, {"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]}
{"messages": [{"role": "system", "content": "You are..."}, {"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]}
{"messages": [{"role": "system", "content": "You are..."}, {"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]}

Der philschmid/gretel-synthetic-text-to-sql-Repository enthält über 100.000 Beispiele. Um den Leitfaden klein zu halten, wird er auf 10.000 Beispiele herunterskaliert.

Sie können jetzt die Hugging Face Datasets-Bibliothek verwenden, um den Datensatz zu laden und eine Promptvorlage zu erstellen, um die Anweisung in natürlicher Sprache, die Schemadefinition und eine Systemmeldung für Ihren Assistenten zu kombinieren.

from datasets import load_dataset

# System message for the assistant
system_message = """You are a text to SQL query translator. Users will ask you questions in English and you will generate a SQL query based on the provided SCHEMA."""

# User prompt that combines the user query and the schema
user_prompt = """Given the <USER_QUERY> and the <SCHEMA>, generate the corresponding SQL command to retrieve the desired data, considering the query's syntax, semantics, and schema constraints.

<SCHEMA>
{context}
</SCHEMA>

<USER_QUERY>
{question}
</USER_QUERY>
"""
def create_conversation(sample):
  return {
    "messages": [
      # {"role": "system", "content": system_message},
      {"role": "user", "content": user_prompt.format(question=sample["sql_prompt"], context=sample["sql_context"])},
      {"role": "assistant", "content": sample["sql"]}
    ]
  }

# Load dataset from the hub
dataset = load_dataset("philschmid/gretel-synthetic-text-to-sql", split="train")
dataset = dataset.shuffle().select(range(12500))

# Convert dataset to OAI messages
dataset = dataset.map(create_conversation, remove_columns=dataset.features,batched=False)
# split dataset into 10,000 training samples and 2,500 test samples
dataset = dataset.train_test_split(test_size=2500/12500)

# Print formatted user prompt
print(dataset["train"][345]["messages"][1]["content"])

Gemma mit TRL und dem SFTTrainer optimieren

Jetzt können Sie Ihr Modell optimieren. Mit dem SFTTrainer von Hugging Face TRL können Sie offene LLMs ganz einfach mithilfe von Labels optimieren. Die SFTTrainer ist eine abgeleitete Klasse der Trainer aus der transformers-Bibliothek und unterstützt dieselben Funktionen wie Logging, Bewertung und Checkpointing. Zusätzlich bietet sie aber noch weitere praktische Funktionen, darunter:

Dataset-Formatierung, einschließlich Konversations- und Anleitungsformaten
Nur auf Fertigstellungen trainieren, Prompts ignorieren
Datasets für ein effizienteres Training verpacken
Unterstützung für die parametereffiziente Feinabstimmung (PEFT), einschließlich QloRA
Modell und Tokenizer für die Konversationsoptimierung vorbereiten (z. B. spezielle Tokens hinzufügen)

Im folgenden Code werden das Gemma-Modell und der Tokenizer von Hugging Face geladen und die Quantisierungskonfiguration initialisiert.

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, AutoModelForImageTextToText, BitsAndBytesConfig

# Hugging Face model id
model_id = "google/gemma-3-1b-pt" # or `google/gemma-3-4b-pt`, `google/gemma-3-12b-pt`, `google/gemma-3-27b-pt`

# Select model class based on id
if model_id == "google/gemma-3-1b-pt":
    model_class = AutoModelForCausalLM
else:
    model_class = AutoModelForImageTextToText

# Check if GPU benefits from bfloat16
if torch.cuda.get_device_capability()[0] >= 8:
    torch_dtype = torch.bfloat16
else:
    torch_dtype = torch.float16

# Define model init arguments
model_kwargs = dict(
    attn_implementation="eager", # Use "flash_attention_2" when running on Ampere or newer GPU
    torch_dtype=torch_dtype, # What torch dtype to use, defaults to auto
    device_map="auto", # Let torch decide how to load the model
)

# BitsAndBytesConfig: Enables 4-bit quantization to reduce model size/memory usage
model_kwargs["quantization_config"] = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type='nf4',
    bnb_4bit_compute_dtype=model_kwargs['torch_dtype'],
    bnb_4bit_quant_storage=model_kwargs['torch_dtype'],
)

# Load model and tokenizer
model = model_class.from_pretrained(model_id, **model_kwargs)
tokenizer = AutoTokenizer.from_pretrained("google/gemma-3-1b-it") # Load the Instruction Tokenizer to use the official Gemma template

Der SFTTrainer unterstützt eine native Einbindung in peft, wodurch sich LLMs mit QLoRA ganz einfach und effizient optimieren lassen. Sie müssen nur eine LoraConfig erstellen und dem Trainer zur Verfügung stellen.

from peft import LoraConfig

peft_config = LoraConfig(
    lora_alpha=16,
    lora_dropout=0.05,
    r=16,
    bias="none",
    target_modules="all-linear",
    task_type="CAUSAL_LM",
    modules_to_save=["lm_head", "embed_tokens"] # make sure to save the lm_head and embed_tokens as you train the special tokens
)

Bevor Sie mit dem Training beginnen können, müssen Sie den Hyperparameter, den Sie verwenden möchten, in einer SFTConfig-Instanz definieren.

from trl import SFTConfig

args = SFTConfig(
    output_dir="gemma-text-to-sql",         # directory to save and repository id
    max_seq_length=512,                     # max sequence length for model and packing of the dataset
    packing=True,                           # Groups multiple samples in the dataset into a single sequence
    num_train_epochs=3,                     # number of training epochs
    per_device_train_batch_size=1,          # batch size per device during training
    gradient_accumulation_steps=4,          # number of steps before performing a backward/update pass
    gradient_checkpointing=True,            # use gradient checkpointing to save memory
    optim="adamw_torch_fused",              # use fused adamw optimizer
    logging_steps=10,                       # log every 10 steps
    save_strategy="epoch",                  # save checkpoint every epoch
    learning_rate=2e-4,                     # learning rate, based on QLoRA paper
    fp16=True if torch_dtype == torch.float16 else False,   # use float16 precision
    bf16=True if torch_dtype == torch.bfloat16 else False,   # use bfloat16 precision
    max_grad_norm=0.3,                      # max gradient norm based on QLoRA paper
    warmup_ratio=0.03,                      # warmup ratio based on QLoRA paper
    lr_scheduler_type="constant",           # use constant learning rate scheduler
    push_to_hub=True,                       # push model to hub
    report_to="tensorboard",                # report metrics to tensorboard
    dataset_kwargs={
        "add_special_tokens": False, # We template with special tokens
        "append_concat_token": True, # Add EOS token as separator token between examples
    }
)

Sie haben jetzt alle Bausteine, die Sie zum Erstellen Ihrer SFTTrainer benötigen, um mit dem Training Ihres Modells zu beginnen.

from trl import SFTTrainer

# Create Trainer object
trainer = SFTTrainer(
    model=model,
    args=args,
    train_dataset=dataset["train"],
    peft_config=peft_config,
    processing_class=tokenizer
)

Starten Sie das Training durch einen Aufruf der Methode train().

# Start training, the model will be automatically saved to the Hub and the output directory
trainer.train()

# Save the final model again to the Hugging Face Hub
trainer.save_model()

Bevor Sie Ihr Modell testen können, müssen Sie den Arbeitsspeicher freigeben.

# free the memory again
del model
del trainer
torch.cuda.empty_cache()

Bei der Verwendung von QLoRA werden nur Adapter und nicht das vollständige Modell trainiert. Das bedeutet, dass beim Speichern des Modells während des Trainings nur die Adaptergewichte und nicht das vollständige Modell gespeichert werden. Wenn Sie das vollständige Modell speichern möchten, um die Verwendung mit Serving-Stacks wie vLLM oder TGI zu vereinfachen, können Sie die Adaptergewichte mit der Methode merge_and_unload in die Modellgewichte einfügen und das Modell dann mit der Methode save_pretrained speichern. Dadurch wird ein Standardmodell gespeichert, das für die Inferenz verwendet werden kann.

from peft import PeftModel

# Load Model base model
model = model_class.from_pretrained(model_id, low_cpu_mem_usage=True)

# Merge LoRA and base model and save
peft_model = PeftModel.from_pretrained(model, args.output_dir)
merged_model = peft_model.merge_and_unload()
merged_model.save_pretrained("merged_model", safe_serialization=True, max_shard_size="2GB")

processor = AutoTokenizer.from_pretrained(args.output_dir)
processor.save_pretrained("merged_model")

Modellinferenz testen und SQL-Abfragen generieren

Nach Abschluss des Trainings sollten Sie Ihr Modell bewerten und testen. Sie können verschiedene Stichproben aus dem Testdatensatz laden und das Modell anhand dieser Stichproben bewerten.

import torch
from transformers import pipeline

model_id = "gemma-text-to-sql"

# Load Model with PEFT adapter
model = model_class.from_pretrained(
  model_id,
  device_map="auto",
  torch_dtype=torch_dtype,
  attn_implementation="eager",
)
tokenizer = AutoTokenizer.from_pretrained(model_id)

Laden Sie eine zufällige Stichprobe aus dem Testdatensatz und generieren Sie einen SQL-Befehl.

from random import randint
import re

# Load the model and tokenizer into the pipeline
pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)

# Load a random sample from the test dataset
rand_idx = randint(0, len(dataset["test"]))
test_sample = dataset["test"][rand_idx]

# Convert as test example into a prompt with the Gemma template
stop_token_ids = [tokenizer.eos_token_id, tokenizer.convert_tokens_to_ids("<end_of_turn>")]
prompt = pipe.tokenizer.apply_chat_template(test_sample["messages"][:2], tokenize=False, add_generation_prompt=True)

# Generate our SQL query.
outputs = pipe(prompt, max_new_tokens=256, do_sample=False, temperature=0.1, top_k=50, top_p=0.1, eos_token_id=stop_token_ids, disable_compile=True)

# Extract the user query and original answer
print(f"Context:\n", re.search(r'<SCHEMA>\n(.*?)\n</SCHEMA>', test_sample['messages'][0]['content'], re.DOTALL).group(1).strip())
print(f"Query:\n", re.search(r'<USER_QUERY>\n(.*?)\n</USER_QUERY>', test_sample['messages'][0]['content'], re.DOTALL).group(1).strip())
print(f"Original Answer:\n{test_sample['messages'][1]['content']}")
print(f"Generated Answer:\n{outputs[0]['generated_text'][len(prompt):].strip()}")

Zusammenfassung und nächste Schritte

In dieser Anleitung haben Sie gelernt, wie Sie ein Gemma-Modell mithilfe von TRL und QLoRA optimieren. Sehen Sie sich als Nächstes die folgenden Dokumente an: