In diesem Leitfaden erfahren Sie, wie Sie Gemma mithilfe von Transformers und TRL von Hugging Face auf einen benutzerdefinierten Bild- und Textdatensatz für eine visuelle Aufgabe (Generieren von Produktbeschreibungen) optimieren. Informationen in diesem Dokument:
- Was ist Quantized Low-Rank Adaptation (QLoRA)?
- Entwicklungsumgebung einrichten
- Dataset für die Feinabstimmung für Aufgaben im Bereich Computer Vision erstellen und vorbereiten
- Gemma mit TRL und dem SFTTrainer optimieren
- Testen Sie die Modellinferenz und generieren Sie Produktbeschreibungen aus Bildern und Text.
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.
# Install Pytorch & other libraries
%pip install "torch>=2.4.0" tensorboard torchvision
# Install Gemma release branch from Hugging Face
%pip install git+https://github.com/huggingface/transformers@v4.49.0-Gemma-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" \
"pillow==11.1.0" \
protobuf \
sentencepiece
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-4b-pt (oder der entsprechenden Modellseite für das von Ihnen verwendete gesichtsfähige Gemma-Modell) 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 mithilfe von Colab-Secrets sicher verwenden. Andernfalls können Sie das Token direkt in der login-Methode 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:
- Feinabstimmung eines Gemma-Modells, um prägnante, SEO-optimierte Produktbeschreibungen für eine E-Commerce-Plattform zu generieren, die speziell auf die mobile Suche zugeschnitten sind.
In diesem Leitfaden wird der Datensatz philschmid/amazon-product-descriptions-vlm verwendet, ein Datensatz mit Produktbeschreibungen von Amazon, einschließlich Produktbildern und ‑kategorien.
Hugging Face TRL unterstützt multimodale Unterhaltungen. Wichtig ist die Rolle „image“, die der Verarbeitungsklasse mitteilt, dass sie das Bild laden soll. Die Struktur sollte folgendermaßen aussehen:
{"messages": [{"role": "system", "content": [{"type": "text", "text":"You are..."}]}, {"role": "user", "content": [{"type": "text", "text": "..."}, {"type": "image"}]}, {"role": "assistant", "content": [{"type": "text", "text": "..."}]}]}
{"messages": [{"role": "system", "content": [{"type": "text", "text":"You are..."}]}, {"role": "user", "content": [{"type": "text", "text": "..."}, {"type": "image"}]}, {"role": "assistant", "content": [{"type": "text", "text": "..."}]}]}
{"messages": [{"role": "system", "content": [{"type": "text", "text":"You are..."}]}, {"role": "user", "content": [{"type": "text", "text": "..."}, {"type": "image"}]}, {"role": "assistant", "content": [{"type": "text", "text": "..."}]}]}
Sie können jetzt die Hugging Face Datasets-Bibliothek verwenden, um den Datensatz zu laden und eine Promptvorlage zu erstellen, um das Bild, den Produktnamen und die Kategorie zu kombinieren und eine Systemmeldung hinzuzufügen. Der Datensatz enthält Bilder als Pil.Image-Objekte.
from datasets import load_dataset
from PIL import Image
# System message for the assistant
system_message = "You are an expert product description writer for Amazon."
# User prompt that combines the user query and the schema
user_prompt = """Create a Short Product description based on the provided <PRODUCT> and <CATEGORY> and image.
Only return description. The description should be SEO optimized and for a better mobile search experience.
<PRODUCT>
{product}
</PRODUCT>
<CATEGORY>
{category}
</CATEGORY>
"""
# Convert dataset to OAI messages
def format_data(sample):
return {
"messages": [
{
"role": "system",
"content": [{"type": "text", "text": system_message}],
},
{
"role": "user",
"content": [
{
"type": "text",
"text": user_prompt.format(
product=sample["Product Name"],
category=sample["Category"],
),
},
{
"type": "image",
"image": sample["image"],
},
],
},
{
"role": "assistant",
"content": [{"type": "text", "text": sample["description"]}],
},
],
}
def process_vision_info(messages: list[dict]) -> list[Image.Image]:
image_inputs = []
# Iterate through each conversation
for msg in messages:
# Get content (ensure it's a list)
content = msg.get("content", [])
if not isinstance(content, list):
content = [content]
# Check each content element for images
for element in content:
if isinstance(element, dict) and (
"image" in element or element.get("type") == "image"
):
# Get the image and convert to RGB
if "image" in element:
image = element["image"]
else:
image = element
image_inputs.append(image.convert("RGB"))
return image_inputs
# Load dataset from the hub
dataset = load_dataset("philschmid/amazon-product-descriptions-vlm", split="train")
# Convert dataset to OAI messages
# need to use list comprehension to keep Pil.Image type, .mape convert image to bytes
dataset = [format_data(sample) for sample in dataset]
print(dataset[345]["messages"])
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 AutoProcessor, AutoModelForImageTextToText, BitsAndBytesConfig
# Hugging Face model id
model_id = "google/gemma-3-4b-pt" # or `google/gemma-3-12b-pt`, `google/gemma-3-27-pt`
# Check if GPU benefits from bfloat16
if torch.cuda.get_device_capability()[0] < 8:
raise ValueError("GPU does not support bfloat16, please use a GPU that supports bfloat16.")
# Define model init arguments
model_kwargs = dict(
attn_implementation="eager", # Use "flash_attention_2" when running on Ampere or newer GPU
torch_dtype=torch.bfloat16, # What torch dtype to use, defaults to auto
device_map="auto", # Let torch decide how to load the model
)
# BitsAndBytesConfig int-4 config
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 = AutoModelForImageTextToText.from_pretrained(model_id, **model_kwargs)
processor = AutoProcessor.from_pretrained("google/gemma-3-4b-it")
Die SFTTrainer unterstützt eine integrierte Einbindung in peft, sodass LLMs mit QLoRA ganz einfach und effizient optimiert werden können. 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",
],
)
Bevor Sie mit dem Training beginnen können, müssen Sie den Hyperparameter, den Sie verwenden möchten, in einem SFTConfig und einem benutzerdefinierten collate_fn für die Bildverarbeitung definieren. Die collate_fn wandelt die Nachrichten mit Text und Bildern in ein Format um, das das Modell verstehen kann.
from trl import SFTConfig
args = SFTConfig(
output_dir="gemma-product-description", # directory to save and repository id
num_train_epochs=1, # 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=5, # log every 5 steps
save_strategy="epoch", # save checkpoint every epoch
learning_rate=2e-4, # learning rate, based on QLoRA paper
bf16=True, # 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
gradient_checkpointing_kwargs={
"use_reentrant": False
}, # use reentrant checkpointing
dataset_text_field="", # need a dummy field for collator
dataset_kwargs={"skip_prepare_dataset": True}, # important for collator
)
args.remove_unused_columns = False # important for collator
# Create a data collator to encode text and image pairs
def collate_fn(examples):
texts = []
images = []
for example in examples:
image_inputs = process_vision_info(example["messages"])
text = processor.apply_chat_template(
example["messages"], add_generation_prompt=False, tokenize=False
)
texts.append(text.strip())
images.append(image_inputs)
# Tokenize the texts and process the images
batch = processor(text=texts, images=images, return_tensors="pt", padding=True)
# The labels are the input_ids, and we mask the padding tokens and image tokens in the loss computation
labels = batch["input_ids"].clone()
# Mask image tokens
image_token_id = [
processor.tokenizer.convert_tokens_to_ids(
processor.tokenizer.special_tokens_map["boi_token"]
)
]
# Mask tokens for not being used in the loss computation
labels[labels == processor.tokenizer.pad_token_id] = -100
labels[labels == image_token_id] = -100
labels[labels == 262144] = -100
batch["labels"] = labels
return batch
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
trainer = SFTTrainer(
model=model,
args=args,
train_dataset=dataset,
peft_config=peft_config,
processing_class=processor,
data_collator=collate_fn,
)
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 = AutoModelForImageTextToText.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 = AutoProcessor.from_pretrained(args.output_dir)
processor.save_pretrained("merged_model")
Modellinferenz testen und Produktbeschreibungen 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
# Load Model with PEFT adapter
model = AutoModelForImageTextToText.from_pretrained(
args.output_dir,
device_map="auto",
torch_dtype=torch.bfloat16,
attn_implementation="eager",
)
processor = AutoProcessor.from_pretrained(args.output_dir)
Sie können die Inferenz testen, indem Sie einen Produktnamen, eine Kategorie und ein Bild angeben. Der sample enthält eine Marvel-Actionfigur.
import requests
from PIL import Image
# Test sample with Product Name, Category and Image
sample = {
"product_name": "Hasbro Marvel Avengers-Serie Marvel Assemble Titan-Held, Iron Man, 30,5 cm Actionfigur",
"category": "Toys & Games | Toy Figures & Playsets | Action Figures",
"image": Image.open(requests.get("https://m.media-amazon.com/images/I/81+7Up7IWyL._AC_SY300_SX300_.jpg", stream=True).raw).convert("RGB")
}
def generate_description(sample, model, processor):
# Convert sample into messages and then apply the chat template
messages = [
{"role": "system", "content": [{"type": "text", "text": system_message}]},
{"role": "user", "content": [
{"type": "image","image": sample["image"]},
{"type": "text", "text": user_prompt.format(product=sample["product_name"], category=sample["category"])},
]},
]
text = processor.apply_chat_template(
messages, tokenize=False, add_generation_prompt=True
)
# Process the image and text
image_inputs = process_vision_info(messages)
# Tokenize the text and process the images
inputs = processor(
text=[text],
images=image_inputs,
padding=True,
return_tensors="pt",
)
# Move the inputs to the device
inputs = inputs.to(model.device)
# Generate the output
stop_token_ids = [processor.tokenizer.eos_token_id, processor.tokenizer.convert_tokens_to_ids("<end_of_turn>")]
generated_ids = model.generate(**inputs, max_new_tokens=256, top_p=1.0, do_sample=True, temperature=0.8, eos_token_id=stop_token_ids, disable_compile=True)
# Trim the generation and decode the output to text
generated_ids_trimmed = [out_ids[len(in_ids) :] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
output_text = processor.batch_decode(
generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
)
return output_text[0]
# generate the description
description = generate_description(sample, model, processor)
print(description)
Zusammenfassung und nächste Schritte
In dieser Anleitung haben Sie gelernt, wie Sie ein Gemma-Modell für Aufgaben im Bereich Computer Vision mithilfe von TRL und QLoRA optimieren, insbesondere für die Generierung von Produktbeschreibungen. Sehen Sie sich als Nächstes die folgenden Dokumente an:
- Weitere Informationen zum Generieren von Text mit einem Gemma-Modell
- Weitere Informationen zum Optimieren von Gemma für Textaufgaben mit Hugging Face Transformers
- Weitere Informationen zur verteilten Feinabstimmung und Inferenz für ein Gemma-Modell
- Weitere Informationen zum Verwenden offener Gemma-Modelle mit Vertex AI
- Weitere Informationen zum Optimieren von Gemma mit KerasNLP und zum Bereitstellen in Vertex AI