Ky udhëzues ju udhëzon se si ta përshtatni Gemma-n në një grup të dhënash të personalizuara nga teksti në SQL duke përdorur Hugging Face Transformers dhe TRL . Do të mësoni:
- Çfarë është Përshtatja e Kuantizuar me Rang të Ulët (QLoRA)
- Konfiguro mjedisin e zhvillimit
- Krijo dhe përgatit të dhënat e rregullimit të imët
- Përmirëso Gemma-n duke përdorur TRL dhe SFTTrainer
- Testimi i Modelit të Inferencës dhe gjenerimi i pyetjeve SQL
Çfarë është Përshtatja e Kuantizuar me Rang të Ulët (QLoRA)
Ky udhëzues demonstron përdorimin e Adaptimit të Kuantizuar me Rang të Ulët (QLoRA) , i cili u shfaq si një metodë popullore për të rregulluar në mënyrë efikase LLM-të, pasi zvogëlon kërkesat për burime llogaritëse duke ruajtur performancë të lartë. Në QloRA, modeli i para-trajnuar kuantizohet në 4-bit dhe peshat ngrihen. Pastaj shtresat e adaptorit të trajnueshëm (LoRA) bashkangjiten dhe vetëm shtresat e adaptorit trajnohen. Më pas, peshat e adaptorit mund të bashkohen me modelin bazë ose të mbahen si një adaptor i veçantë.
Konfiguro mjedisin e zhvillimit
Hapi i parë është instalimi i Bibliotekave të Face Hugging, duke përfshirë TRL, dhe grupeve të të dhënave për të akorduar modelin e hapur, duke përfshirë teknika të ndryshme RLHF dhe shtrirjeje.
# 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.21.0" \
"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
Shënim: Nëse përdorni një GPU me arkitekturë Ampere (siç është NVIDIA L4) ose më të re, mund të përdorni Flash Attention. Flash Attention është një metodë që përshpejton ndjeshëm llogaritjet dhe zvogëlon përdorimin e memories nga gjatësia kuadratike në atë lineare në sekuencë, duke çuar në përshpejtimin e trajnimit deri në 3 herë. Mësoni më shumë në FlashAttention .
Para se të filloni stërvitjen, duhet të siguroheni që i keni pranuar kushtet e përdorimit për Gemma-n. Mund ta pranoni licencën në Hugging Face duke klikuar butonin "Pajtohem dhe hyj në repozitor" në faqen e modelit në: http://huggingface.co/google/gemma-3-1b-pt
Pasi ta keni pranuar licencën, ju nevojitet një Hugging Face Token i vlefshëm për të aksesuar modelin. Nëse po përdorni brenda një Google Colab, mund ta përdorni në mënyrë të sigurt Hugging Face Token tuaj duke përdorur sekretet e Colab, përndryshe mund ta caktoni tokenin direkt në metodën login . Sigurohuni që tokeni juaj të ketë edhe akses shkrimi, ndërsa e shtyni modelin tuaj në Qendër gjatë trajnimit.
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)
Krijo dhe përgatit të dhënat e rregullimit të imët
Kur përmirësoni LLM-të, është e rëndësishme të dini rastin e përdorimit dhe detyrën që doni të zgjidhni. Kjo ju ndihmon të krijoni një grup të dhënash për të përmirësuar modelin tuaj. Nëse nuk e keni përcaktuar ende rastin e përdorimit, mund të dëshironi të ktheheni në fazën fillestare.
Si shembull, ky udhëzues përqendrohet në rastin e mëposhtëm të përdorimit:
- Përmirësoni një gjuhë natyrore në modelin SQL për integrim të përsosur në një mjet analize të të dhënave. Objektivi është të zvogëlohet ndjeshëm koha dhe ekspertiza e kërkuar për gjenerimin e pyetjeve SQL, duke u mundësuar edhe përdoruesve jo-teknikë të nxjerrin njohuri kuptimplote nga të dhënat.
Konvertimi i tekstit në SQL mund të jetë një rast i mirë përdorimi për përmirësimin e imët të LLM-ve, pasi është një detyrë komplekse që kërkon shumë njohuri (të brendshme) rreth të dhënave dhe gjuhës SQL.
Pasi të keni përcaktuar se rregullimi i imët është zgjidhja e duhur, ju nevojitet një grup të dhënash për ta rregulluar atë. Grupi i të dhënave duhet të jetë një grup i larmishëm demonstrimesh të detyrës/detyrave që dëshironi të zgjidhni. Ka disa mënyra për të krijuar një grup të tillë të dhënash, duke përfshirë:
- Duke përdorur grupe të dhënash ekzistuese me burim të hapur, siç është Spider
- Duke përdorur grupe të dhënash sintetike të krijuara nga LLM, siç është Alpaca
- Duke përdorur grupe të dhënash të krijuara nga njerëzit, siç është Dolly .
- Duke përdorur një kombinim të metodave, siç është Orca
Secila prej metodave ka avantazhet dhe disavantazhet e veta dhe varet nga buxheti, koha dhe kërkesat e cilësisë. Për shembull, përdorimi i një grupi të dhënash ekzistuese është më i lehtë, por mund të mos jetë i përshtatur për rastin tuaj specifik të përdorimit, ndërsa përdorimi i ekspertëve të fushës mund të jetë më i sakti, por mund të kërkojë shumë kohë dhe të jetë i kushtueshëm. Është gjithashtu e mundur të kombinohen disa metoda për të krijuar një grup të dhënash udhëzimesh, siç tregohet në Orca: Mësimi Progresiv nga Gjurmët Komplekse të Shpjegimit të GPT-4.
Ky udhëzues përdor një grup të dhënash tashmë ekzistues ( philschmid/gretel-synthetic-text-to-sql ), një grup të dhënash sintetike Text-to-SQL me cilësi të lartë që përfshin udhëzime në gjuhën natyrore, përkufizime skemash, arsyetim dhe pyetjen përkatëse SQL.
Hugging Face TRL mbështet modelimin automatik të formateve të të dhënave të bisedave. Kjo do të thotë që ju vetëm duhet të konvertoni të dhënat tuaja në objektet e duhura json, dhe trl kujdeset për modelimin dhe vendosjen e tyre në formatin e duhur.
{"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": "..."}]}
Philschmid/gretel-synthetic-text-to-sql përmban mbi 100 mijë mostra. Për ta mbajtur udhëzuesin të vogël, ai është reduktuar në vetëm 10,000 mostra.
Tani mund të përdorni bibliotekën e të dhënave Hugging Face për të ngarkuar të dhënat dhe për të krijuar një shabllon të shpejtë për të kombinuar udhëzimet e gjuhës natyrore, përkufizimin e skemës dhe për të shtuar një mesazh sistemi për asistentin tuaj.
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"])
Përmirëso Gemma-n duke përdorur TRL dhe SFTTrainer
Tani jeni gati të përmirësoni modelin tuaj. Hugging Face TRL SFTTrainer e bën të thjeshtë mbikëqyrjen e optimizimit të LLM-ve të hapura. SFTTrainer është një nënklasë e Trainer nga biblioteka transformers dhe mbështet të gjitha veçoritë e njëjta, duke përfshirë regjistrimin, vlerësimin dhe pikat e kontrollit, por shton veçori shtesë të cilësisë së jetës, duke përfshirë:
- Formatimi i të dhënave, duke përfshirë formatet bisedore dhe të udhëzimeve
- Trajnim vetëm për përfundimet, duke injoruar kërkesat
- Paketimi i të dhënave për trajnim më efikas
- Mbështetje për rregullim të imët me efikasitet të parametrave (PEFT) duke përfshirë QloRA
- Përgatitja e modelit dhe tokenizuesit për rregullime të hollësishme bisedore (siç është shtimi i tokenëve specialë)
Kodi i mëposhtëm ngarkon modelin Gemma dhe tokenizuesin nga Hugging Face dhe inicializon konfigurimin e kuantizimit.
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
SFTTrainer mbështet një integrim nativ me peft , gjë që e bën të thjeshtë akordimin efikas të LLM-ve duke përdorur QLoRA. Ju vetëm duhet të krijoni një LoraConfig dhe t'ia jepni trajnerit.
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
)
Para se të filloni trajnimin tuaj, duhet të përcaktoni hiperparametrin që dëshironi të përdorni në një instancë SFTConfig .
from trl import SFTConfig
args = SFTConfig(
output_dir="gemma-text-to-sql", # directory to save and repository id
max_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
}
)
Tani keni çdo bllok ndërtimi që ju nevojitet për të krijuar SFTTrainer in tuaj për të filluar trajnimin e modelit tuaj.
from trl import SFTTrainer
# Create Trainer object
trainer = SFTTrainer(
model=model,
args=args,
train_dataset=dataset["train"],
peft_config=peft_config,
processing_class=tokenizer
)
Filloni stërvitjen duke thirrur metodën 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()
Para se të testoni modelin tuaj, sigurohuni që të lironi memorien.
# free the memory again
del model
del trainer
torch.cuda.empty_cache()
Kur përdorni QLoRA, ju trajnoni vetëm adaptorët dhe jo modelin e plotë. Kjo do të thotë që kur ruani modelin gjatë trajnimit, ju ruani vetëm peshat e adaptorëve dhe jo modelin e plotë. Nëse dëshironi të ruani modelin e plotë, gjë që e bën më të lehtë përdorimin me pirgje shërbimi si vLLM ose TGI, mund të bashkoni peshat e adaptorëve në peshat e modelit duke përdorur metodën merge_and_unload dhe më pas të ruani modelin me metodën save_pretrained . Kjo ruan një model të parazgjedhur, i cili mund të përdoret për përfundime.
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")
Testimi i Modelit të Inferencës dhe gjenerimi i pyetjeve SQL
Pasi të keni mbaruar trajnimin, do të dëshironi të vlerësoni dhe testoni modelin tuaj. Mund të ngarkoni mostra të ndryshme nga të dhënat e testimit dhe të vlerësoni modelin në ato mostra.
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)
Le të ngarkojmë një mostër të rastësishme nga të dhënat e testimit dhe të gjenerojmë një komandë SQL.
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"])-1)
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()}")
Përmbledhje dhe hapat e mëtejshëm
Ky tutorial trajtoi mënyrën e përshtatjes së imët të një modeli Gemma duke përdorur TRL dhe QLoRA. Shikoni dokumentet e mëposhtme më poshtë:
- Mësoni si të gjeneroni tekst me një model Gemma .
- Mësoni si ta përshtatni imët Gemmën për detyrat e shikimit duke përdorur Transformuesit e Fytyrës përqafuese .
- Mësoni si ta akordoni plotësisht modelin duke përdorur Transformuesit e Fytyrës përqafuese .
- Mësoni si të kryeni rregullime të hollësishme të shpërndara dhe nxjerrje përfundimesh në një model Gemma .
- Mësoni si të përdorni modelet e hapura të Gemma me Vertex AI .
- Mësoni si ta akordoni Gemma-n duke përdorur KerasNLP dhe ta vendosni në Vertex AI .