Rregulloni mirë EmbeddingGemma

Shikoni në ai.google.dev Ekzekutoni në Google Colab Vraponi në Kaggle Hapni në Vertex AI Shiko burimin në GitHub

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

Imagjinoni që kompania juaj, "Shibuya Financial" ofron produkte të ndryshme financiare komplekse si trustet e investimeve, llogaritë NISA (një llogari kursimi me avantazh tatimor) dhe kredi për shtëpi. Ekipi juaj i mbështetjes së klientit përdor një bazë të brendshme njohurish për të gjetur shpejt përgjigjet për pyetjet e klientëve.

Konfigurimi

Përpara se të filloni këtë tutorial, plotësoni hapat e mëposhtëm:

  • Merrni akses në EmbeddingGemma duke u identifikuar në Hugging Face dhe duke zgjedhur Acknowledge License për një model Gemma.
  • Gjeneroni një Token të Qasjes për Hugging Face dhe përdorni atë për t'u identifikuar nga Colab.

Ky fletore do të funksionojë ose në CPU ose GPU.

Instaloni paketat Python

Instaloni bibliotekat e nevojshme për ekzekutimin e modelit EmbeddingGemma dhe gjenerimin e ngulitjeve. Sentence Transformers është një kornizë Python për futjen e tekstit dhe imazhit. Për më shumë informacion, shihni dokumentacionin e Transformuesve të Fjalive .

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

Pasi të keni pranuar licencën, ju nevojitet një shenjë e vlefshme Hugging Face për të hyrë në model.

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

Modeli i ngarkimit

Përdorni bibliotekat 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ërgatitni grupin e të dhënave të rregullimit të imët

Kjo është pjesa më e rëndësishme. Ju duhet të krijoni një grup të dhënash që i mëson modelit se çfarë do të thotë "i ngjashëm" në kontekstin tuaj specifik. Këto të dhëna shpesh strukturohen si treshe: (spirancë, pozitive, negative)

  • Anchor: Pyetja ose fjalia origjinale.
  • Pozitive: Një fjali që është semantikisht shumë e ngjashme ose identike me spirancën.
  • Negative: Një fjali që është në një temë të lidhur, por semantikisht e dallueshme.

Në këtë shembull, ne përgatitëm vetëm 3 treshe, por për një aplikim të vërtetë, do t'ju 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
})

Përpara rregullimit të imët

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

  1. Dokumenti: Hapja e një llogarie NISA (Rezultati: 0.45)
  2. Dokument: Hapja e një llogarie të rregullt kursimi (Rezultati: 0,48) <- Rezultat i ngjashëm, potencialisht konfuz
  3. Dokumenti: Udhëzuesi i aplikimit për kredi për shtëpi (Vendimi: 0.42)
task_name = "STS"

def get_scores(query, documents):
  # Calculate embeddings by calling model.encode()
  query_embeddings = model.encode(query, prompt=task_name)
  doc_embeddings = model.encode(documents, prompt=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.45698774
Document:  Opening a Regular Savings Account -> 🤖 Score:  0.48092696
Document:  Home Loan Application Guide -> 🤖 Score:  0.42127067

Trajnimi

Duke përdorur një kornizë si sentence-transformers në Python, modeli bazë gradualisht mëson dallimet delikate në fjalorin tuaj 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.6449194
Document:  Opening a Regular Savings Account -> 🤖 Score:  0.44123
Document:  Home Loan Application Guide -> 🤖 Score:  0.46752414
Step 6 finished. Running evaluation:
Document:  Opening a NISA Account -> 🤖 Score:  0.68873787
Document:  Opening a Regular Savings Account -> 🤖 Score:  0.34069622
Document:  Home Loan Application Guide -> 🤖 Score:  0.50065553
Step 9 finished. Running evaluation:
Document:  Opening a NISA Account -> 🤖 Score:  0.7148906
Document:  Opening a Regular Savings Account -> 🤖 Score:  0.30480516
Document:  Home Loan Application Guide -> 🤖 Score:  0.52454984
Step 12 finished. Running evaluation:
Document:  Opening a NISA Account -> 🤖 Score:  0.72614634
Document:  Opening a Regular Savings Account -> 🤖 Score:  0.29255486
Document:  Home Loan Application Guide -> 🤖 Score:  0.5370023
Step 15 finished. Running evaluation:
Document:  Opening a NISA Account -> 🤖 Score:  0.7294032
Document:  Opening a Regular Savings Account -> 🤖 Score:  0.2893038
Document:  Home Loan Application Guide -> 🤖 Score:  0.54087913
Step 15 finished. Running evaluation:
Document:  Opening a NISA Account -> 🤖 Score:  0.7294032
Document:  Opening a Regular Savings Account -> 🤖 Score:  0.2893038
Document:  Home Loan Application Guide -> 🤖 Score:  0.54087913
TrainOutput(global_step=15, training_loss=0.009651281436261646, metrics={'train_runtime': 63.2486, 'train_samples_per_second': 0.237, 'train_steps_per_second': 0.237, 'total_flos': 0.0, 'train_loss': 0.009651281436261646, 'epoch': 5.0})

Pas rregullimit të imët

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

  1. Dokument: Hapja e një llogarie NISA (Rezultati: 0.72) <- Shumë më i sigurt
  2. Dokumenti: Hapja e një llogarie të rregullt kursimi (Rezultati: 0,28) <- Qartë më pak e rëndësishme
  3. Dokumenti: Udhëzuesi i aplikimit për kredi për shtëpi (Vendimi: 0.54) 
get_scores(query, documents)

Document:  Opening a NISA Account -> 🤖 Score:  0.7294032
Document:  Opening a Regular Savings Account -> 🤖 Score:  0.2893038
Document:  Home Loan Application Guide -> 🤖 Score:  0.54087913

Për të ngarkuar modelin tuaj në Hugging Face Hub, mund të përdorni metodën push_to_hub nga biblioteka Sentence Transformers.

Ngarkimi i modelit tuaj e bën të lehtë qasjen për përfundime direkt nga Hub, ndarjen me të tjerët dhe versionin e punës suaj. Pasi të jetë ngarkuar, çdokush mund të ngarkojë modelin tuaj me një rresht të vetëm kodi, thjesht duke iu referuar ID-së së tij unike të modelit <username>/my-embedding-gemma 

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

Përmbledhja dhe hapat e mëtejshëm

Tani keni mësuar se si të përshtatni një model EmbeddingGemma për një domen specifik duke e rregulluar atë me bibliotekën Sentence Transformers.

Eksploroni se çfarë mund të bëni më shumë me EmbeddingGemma: