Sintonizo imët EmbeddingGemma

Shiko në ai.google.dev Ekzekuto në Google Colab Ekzekuto në Kaggle Hape në Vertex AI Shiko burimin në GitHub

Rregullimi i imët ndihmon në mbylljen e hendekut midis të kuptuarit të përgjithshëm të një modeli dhe saktësisë së specializuar me performancë të lartë që kërkon aplikacioni yt. Duke qenë se asnjë model i vetëm nuk është i përsosur për çdo detyrë, rregullimi i imët e përshtat atë për domenin tënd specifik.

Imagjino që kompania jote, "Shibuya Financial", ofron produkte të ndryshme financiare komplekse si truste investimi, llogari NISA (një llogari kursimesh me avantazhe tatimore) dhe hua për shtëpi. Ekipi yt i mbështetjes për klientët përdor një bazë të brendshme njohurish për të gjetur me shpejtësi përgjigjet për pyetjet e klientëve.

Konfigurimi

Para se të fillosh këtë udhëzues, përfundo hapat e mëposhtëm:

  • Merr qasje te EmbeddingGemma duke u identifikuar në Hugging Face dhe duke zgjedhur Prano licencën për një model të Gemma.
  • Gjenero një token qasjeje të Hugging Face dhe përdore atë për t'u identifikuar nga Colab.

Ky bllok shënimesh do të ekzekutohet në CPU ose GPU.

Instalo paketat e Python

Instalo bibliotekat e nevojshme për ekzekutimin e modelit EmbeddingGemma dhe gjenerimin e përfaqësimeve. Sentence Transformers është një kuadër i Python për përfaqësimet e tekstit dhe imazheve. Për më shumë informacion, shiko dokumentacionin e Sentence Transformers.

pip install -U sentence-transformers git+https://github.com/huggingface/transformers@v4.56.0-Embedding-Gemma-preview

Pasi të kesh pranuar licencën, të duhet një kod i vlefshëm i Hugging Face për t'u qasur te modeli.

# Login into Hugging Face Hub
from huggingface_hub import login
login()

Ngarko modelin

Përdor bibliotekat e sentence-transformers për të krijuar një shembull të një klase modeli me EmbeddingGemma.

import torch
from sentence_transformers import SentenceTransformer

device = "cuda" if torch.cuda.is_available() else "cpu"

model_id = "google/embeddinggemma-300M"
model = SentenceTransformer(model_id).to(device=device)

print(f"Device: {model.device}")
print(model)
print("Total number of parameters in the model:", sum([p.numel() for _, p in model.named_parameters()]))

Device: cuda:0
SentenceTransformer(
  (0): Transformer({'max_seq_length': 2048, 'do_lower_case': False, 'architecture': 'Gemma3TextModel'})
  (1): Pooling({'word_embedding_dimension': 768, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
  (2): Dense({'in_features': 768, 'out_features': 3072, 'bias': False, 'activation_function': 'torch.nn.modules.linear.Identity'})
  (3): Dense({'in_features': 3072, 'out_features': 768, 'bias': False, 'activation_function': 'torch.nn.modules.linear.Identity'})
  (4): Normalize()
)
Total number of parameters in the model: 307581696

Përgatit grupimin e të dhënave për rafinimin

Kjo është pjesa më e rëndësishme. Duhet të krijosh një grupim të dhënash që i mëson modelit se çfarë do të thotë "i ngjashëm" në kontekstin tënd specifik. Këto të dhëna shpesh strukturohen si treshë: (pikë referimi, pozitive, negative)

  • Ankorë: Kërkesa ose fjalia origjinale.
  • Pozitive: Një fjali që është semantikisht shumë e ngjashme ose identike me fjalinë bazë.
  • Negative: Një fjali që ka të bëjë me një temë të ngjashme, por që është semantikisht e ndryshme.

Në këtë shembull, ne kemi përgatitur vetëm 3 tresh, por për një aplikim të vërtetë, do të të duhet një grup të dhënash shumë më i madh për të performuar mirë.

from datasets import Dataset

dataset = [
    ["How do I open a NISA account?", "What is the procedure for starting a new tax-free investment account?", "I want to check the balance of my regular savings account."],
    ["Are there fees for making an early repayment on a home loan?", "If I pay back my house loan early, will there be any costs?", "What is the management fee for this investment trust?"],
    ["What is the coverage for medical insurance?", "Tell me about the benefits of the health insurance plan.", "What is the cancellation policy for my life insurance?"],
]

# Convert the list-based dataset into a list of dictionaries.
data_as_dicts = [ {"anchor": row[0], "positive": row[1], "negative": row[2]} for row in dataset ]

# Create a Hugging Face `Dataset` object from the list of dictionaries.
train_dataset = Dataset.from_list(data_as_dicts)
print(train_dataset)

Dataset({
    features: ['anchor', 'positive', 'negative'],
    num_rows: 3
})

Para sintonizimit të imët

Një kërkim për "investim pa taksa" mund të ketë dhënë rezultatet e mëposhtme, me rezultatet e ngjashmërisë:

  1. Dokumenti: Hapja e një llogarie NISA (Rezultati: 0,51)
  2. Dokumenti: Hapja e një llogarie të zakonshme kursimesh (Rezultati: 0,50) <- Rezultat i ngjashëm, mund të jetë konfuz
  3. Dokumenti: Udhëzuesi i aplikimit për kredi për banesë (Rezultati: 0,44)
task_name = "STS"

def get_scores(query, documents):
  # Calculate embeddings by calling model.encode()
  query_embeddings = model.encode(query, prompt_name=task_name)
  doc_embeddings = model.encode(documents, prompt_name=task_name)

  # Calculate the embedding similarities
  similarities = model.similarity(query_embeddings, doc_embeddings)

  for idx, doc in enumerate(documents):
    print("Document: ", doc, "-> 🤖 Score: ", similarities.numpy()[0][idx])

query = "I want to start a tax-free installment investment, what should I do?"
documents = ["Opening a NISA Account", "Opening a Regular Savings Account", "Home Loan Application Guide"]

get_scores(query, documents)

Document:  Opening a NISA Account -> 🤖 Score:  0.51571906
Document:  Opening a Regular Savings Account -> 🤖 Score:  0.5035889
Document:  Home Loan Application Guide -> 🤖 Score:  0.4406476

Trajnimi

Duke përdorur një kuadër si sentence-transformers në Python, modeli bazë mëson gradualisht dallimet e vogla në fjalorin tënd financiar.

from sentence_transformers import SentenceTransformerTrainer, SentenceTransformerTrainingArguments
from sentence_transformers.losses import MultipleNegativesRankingLoss
from transformers import TrainerCallback

loss = MultipleNegativesRankingLoss(model)

args = SentenceTransformerTrainingArguments(
    # Required parameter:
    output_dir="my-embedding-gemma",
    # Optional training parameters:
    prompts=model.prompts[task_name],    # use model's prompt to train
    num_train_epochs=5,
    per_device_train_batch_size=1,
    learning_rate=2e-5,
    warmup_ratio=0.1,
    # Optional tracking/debugging parameters:
    logging_steps=train_dataset.num_rows,
    report_to="none",
)

class MyCallback(TrainerCallback):
    "A callback that evaluates the model at the end of eopch"
    def __init__(self, evaluate):
        self.evaluate = evaluate # evaluate function

    def on_log(self, args, state, control, **kwargs):
        # Evaluate the model using text generation
        print(f"Step {state.global_step} finished. Running evaluation:")
        self.evaluate()

def evaluate():
  get_scores(query, documents)

trainer = SentenceTransformerTrainer(
    model=model,
    args=args,
    train_dataset=train_dataset,
    loss=loss,
    callbacks=[MyCallback(evaluate)]
)
trainer.train()

Step 3 finished. Running evaluation:
Document:  Opening a NISA Account -> 🤖 Score:  0.6459116
Document:  Opening a Regular Savings Account -> 🤖 Score:  0.42690125
Document:  Home Loan Application Guide -> 🤖 Score:  0.40419024
Step 6 finished. Running evaluation:
Document:  Opening a NISA Account -> 🤖 Score:  0.68530923
Document:  Opening a Regular Savings Account -> 🤖 Score:  0.3611964
Document:  Home Loan Application Guide -> 🤖 Score:  0.40812016
Step 9 finished. Running evaluation:
Document:  Opening a NISA Account -> 🤖 Score:  0.7168733
Document:  Opening a Regular Savings Account -> 🤖 Score:  0.3449782
Document:  Home Loan Application Guide -> 🤖 Score:  0.44477722
Step 12 finished. Running evaluation:
Document:  Opening a NISA Account -> 🤖 Score:  0.73008573
Document:  Opening a Regular Savings Account -> 🤖 Score:  0.34124148
Document:  Home Loan Application Guide -> 🤖 Score:  0.4676212
Step 15 finished. Running evaluation:
Document:  Opening a NISA Account -> 🤖 Score:  0.73378766
Document:  Opening a Regular Savings Account -> 🤖 Score:  0.34055778
Document:  Home Loan Application Guide -> 🤖 Score:  0.47503752
Step 15 finished. Running evaluation:
Document:  Opening a NISA Account -> 🤖 Score:  0.73378766
Document:  Opening a Regular Savings Account -> 🤖 Score:  0.34055778
Document:  Home Loan Application Guide -> 🤖 Score:  0.47503752
TrainOutput(global_step=15, training_loss=0.009651267528511198, metrics={'train_runtime': 195.3004, 'train_samples_per_second': 0.077, 'train_steps_per_second': 0.077, 'total_flos': 0.0, 'train_loss': 0.009651267528511198, 'epoch': 5.0})

Pas sintonizimit të imët

I njëjti kërkim tani jep rezultate shumë më të qarta:

  1. Dokumenti: Hapja e një llogarie NISA (Rezultati: 0,73) <- Shumë më i sigurt
  2. Dokumenti: Hapja e një llogarie të zakonshme kursimi (Rezultati: 0,34) <- Qartësisht më pak i përshtatshëm
  3. Dokumenti: Udhëzuesi i aplikimit për kredi për banesë (rezultati: 0,47)
get_scores(query, documents)

Document:  Opening a NISA Account -> 🤖 Score:  0.73378766
Document:  Opening a Regular Savings Account -> 🤖 Score:  0.34055778
Document:  Home Loan Application Guide -> 🤖 Score:  0.47503752

Për të ngarkuar modelin tënd te Hugging Face Hub, mund të përdorësh metodën push_to_hub nga biblioteka e Sentence Transformers.

Ngarkimi i modelit tënd e bën të lehtë qasjen për përfundime drejtpërdrejt nga Hub, ndarjen me të tjerët dhe versionimin e punës sate. Pasi të ngarkohet, çdokush mund ta ngarkojë modelin tënd me një rresht të vetëm kodi, thjesht duke iu referuar ID-së unike të modelit <username>/my-embedding-gemma

# Push to Hub
model.push_to_hub("my-embedding-gemma")

Përmbledhja dhe hapat e radhës

Tani ke mësuar se si të përshtatësh një model EmbeddingGemma për një domen specifik duke e përmirësuar atë me bibliotekën Sentence Transformers.

Eksploro se çfarë mund të bësh më shumë me EmbeddingGemma: