Membuat Embedding dengan Sentence Transformers

Lihat di ai.google.dev Jalankan di Google Colab Jalankan di Kaggle Buka di Vertex AI Lihat sumber di GitHub

EmbeddingGemma adalah model penyematan terbuka yang ringan dan dirancang untuk pengambilan cepat dan berkualitas tinggi di perangkat sehari-hari seperti ponsel. Dengan hanya 308 juta parameter, model ini cukup efisien untuk menjalankan teknik AI tingkat lanjut, seperti Retrieval Augmented Generation (RAG), langsung di komputer lokal Anda tanpa memerlukan koneksi internet.

Penyiapan

Sebelum memulai tutorial ini, selesaikan langkah-langkah berikut:

  • Dapatkan akses ke Gemma dengan login ke Hugging Face dan memilih Acknowledge license untuk model Gemma.
  • Buat Token Akses Hugging Face dan gunakan untuk login dari Colab.

Notebook ini akan berjalan di CPU atau GPU.

Menginstal paket Python

Instal library yang diperlukan untuk menjalankan model EmbeddingGemma dan membuat embedding. Sentence Transformers adalah framework Python untuk embedding teks dan gambar. Untuk mengetahui informasi selengkapnya, lihat dokumentasi Sentence Transformers.

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

Setelah menyetujui lisensi, Anda memerlukan Token Hugging Face yang valid untuk mengakses model.

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

Memuat Model

Gunakan library sentence-transformers untuk membuat instance class model dengan 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

Membuat Embedding

Embedding adalah representasi numerik dari teks, seperti kata atau kalimat, yang menangkap makna semantiknya. Pada dasarnya, ini adalah daftar angka (vektor) yang memungkinkan komputer memahami hubungan dan konteks kata.

Mari kita lihat cara EmbeddingGemma memproses tiga kata yang berbeda ["apple", "banana", "car"].

EmbeddingGemma telah dilatih dengan sejumlah besar teks dan telah mempelajari hubungan antara kata dan konsep.

words = ["apple", "banana", "car"]

# Calculate embeddings by calling model.encode()
embeddings = model.encode(words)

print(embeddings)
for idx, embedding in enumerate(embeddings):
  print(f"Embedding {idx+1} (shape): {embedding.shape}")

[[-0.18476306  0.00167681  0.03773484 ... -0.07996225 -0.02348064
   0.00976741]
 [-0.21189538 -0.02657359  0.02513712 ... -0.08042689 -0.01999852
   0.00512146]
 [-0.18924113 -0.02551468  0.04486253 ... -0.06377774 -0.03699806
   0.03973572]]
Embedding 1: (768,)
Embedding 2: (768,)
Embedding 3: (768,)

Model ini menghasilkan vektor numerik untuk setiap kalimat. Vektor sebenarnya sangat panjang (768), tetapi untuk menyederhanakan, vektor tersebut ditampilkan dengan beberapa dimensi.

Kuncinya bukan pada angka-angka itu sendiri, melainkan jarak antara vektor. Jika kita memetakan vektor ini dalam ruang multidimensi, vektor untuk apple dan banana akan sangat berdekatan. Vektor untuk car akan jauh dari dua vektor lainnya.

Menentukan Kemiripan

Di bagian ini, kita menggunakan penyematan untuk menentukan seberapa mirip semantik kalimat yang berbeda. Di sini kami menunjukkan contoh dengan skor kemiripan tinggi, sedang, dan rendah.

  • Kemiripan Tinggi:

    • Kalimat A: "Koki menyiapkan makanan lezat untuk para tamu."
    • Kalimat B: "Makan malam lezat dimasak oleh koki untuk para pengunjung."
    • Alasan: Kedua kalimat mendeskripsikan peristiwa yang sama menggunakan kata dan struktur tata bahasa yang berbeda (kalimat aktif vs. pasif). Keduanya menyampaikan makna inti yang sama.

  • Kemiripan Sedang:

    • Kalimat A: "Dia adalah pakar machine learning."
    • Kalimat B: "Dia sangat tertarik dengan kecerdasan buatan."
    • Alasan: Kedua kalimat tersebut terkait karena machine learning adalah subbidang kecerdasan buatan. Namun, mereka berbicara tentang orang yang berbeda dengan tingkat engagement yang berbeda (pakar vs. minat).

  • Kemiripan Rendah:

    • Kalimat A: "Cuaca di Tokyo cerah hari ini."
    • Kalimat B: "Saya perlu membeli bahan makanan untuk minggu ini."
    • Alasan: Kedua kalimat membahas topik yang sama sekali tidak terkait dan tidak memiliki tumpang-tindih semantik.
# The sentences to encode
sentence_high = [
    "The chef prepared a delicious meal for the guests.",
    "A tasty dinner was cooked by the chef for the visitors."
]
sentence_medium = [
    "She is an expert in machine learning.",
    "He has a deep interest in artificial intelligence."
]
sentence_low = [
    "The weather in Tokyo is sunny today.",
    "I need to buy groceries for the week."
]

for sentence in [sentence_high, sentence_medium, sentence_low]:
  print("🙋‍♂️")
  print(sentence)
  embeddings = model.encode(sentence)
  similarities = model.similarity(embeddings[0], embeddings[1])
  print("`-> 🤖 score: ", similarities.numpy()[0][0])

🙋‍♂️
['The chef prepared a delicious meal for the guests.', 'A tasty dinner was cooked by the chef for the visitors.']
`-> 🤖 score:  0.8002148
🙋‍♂️
['She is an expert in machine learning.', 'He has a deep interest in artificial intelligence.']
`-> 🤖 score:  0.45417833
🙋‍♂️
['The weather in Tokyo is sunny today.', 'I need to buy groceries for the week.']
`-> 🤖 score:  0.22262995

Menggunakan Perintah dengan EmbeddingGemma

Untuk menghasilkan embedding terbaik dengan EmbeddingGemma, Anda harus menambahkan "perintah instruksional" atau "tugas" di awal teks input Anda. Perintah ini mengoptimalkan penyematan untuk tugas tertentu, seperti pengambilan dokumen atau penjawaban pertanyaan, dan membantu model membedakan berbagai jenis input, seperti kueri penelusuran versus dokumen.

Cara Menerapkan Perintah

Anda dapat menerapkan perintah selama inferensi dengan tiga cara.

  1. Menggunakan argumen prompt
    Teruskan string perintah lengkap langsung ke metode encode. Hal ini memberi Anda kontrol yang akurat.

    embeddings = model.encode(
    sentence,
    prompt="task: sentence similarity | query: "
)

  2. Menggunakan argumen prompt_name
    Pilih perintah yang telah ditentukan sebelumnya berdasarkan namanya. Perintah ini dimuat dari konfigurasi model atau selama inisialisasi.

    embeddings = model.encode(sentence, prompt_name="STS")

  3. Menggunakan Perintah Default
    Jika Anda tidak menentukan prompt atau prompt_name, sistem akan otomatis menggunakan perintah yang ditetapkan sebagai default_prompt_name. Jika tidak ada default yang ditetapkan, tidak ada perintah yang diterapkan.

    embeddings = model.encode(sentence)

print("Available tasks:")
for name, prefix in model.prompts.items():
  print(f" {name}: \"{prefix}\"")
print("-"*80)

for sentence in [sentence_high, sentence_medium, sentence_low]:
  print("🙋‍♂️")
  print(sentence)
  embeddings = model.encode(sentence, prompt_name="STS")
  similarities = model.similarity(embeddings[0], embeddings[1])
  print("`-> 🤖 score: ", similarities.numpy()[0][0])

Available tasks:
 query: "task: search result | query: "
 document: "title: none | text: "
 BitextMining: "task: search result | query: "
 Clustering: "task: clustering | query: "
 Classification: "task: classification | query: "
 InstructionRetrieval: "task: code retrieval | query: "
 MultilabelClassification: "task: classification | query: "
 PairClassification: "task: sentence similarity | query: "
 Reranking: "task: search result | query: "
 Retrieval: "task: search result | query: "
 Retrieval-query: "task: search result | query: "
 Retrieval-document: "title: none | text: "
 STS: "task: sentence similarity | query: "
 Summarization: "task: summarization | query: "
--------------------------------------------------------------------------------
🙋‍♂️
['The chef prepared a delicious meal for the guests.', 'A tasty dinner was cooked by the chef for the visitors.']
`-> 🤖 score:  0.9363755
🙋‍♂️
['She is an expert in machine learning.', 'He has a deep interest in artificial intelligence.']
`-> 🤖 score:  0.6425841
🙋‍♂️
['The weather in Tokyo is sunny today.', 'I need to buy groceries for the week.']
`-> 🤖 score:  0.38587403

Kasus Penggunaan: Retrieval-Augmented Generation (RAG)

Untuk sistem RAG, gunakan nilai prompt_name berikut untuk membuat embedding khusus untuk kueri dan dokumen Anda:

  • Untuk Kueri: Gunakan prompt_name="Retrieval-query".

    query_embedding = model.encode(
    "How do I use prompts with this model?",
    prompt_name="Retrieval-query"
)

  • Untuk Dokumen: Gunakan prompt_name="Retrieval-document". Untuk lebih meningkatkan kualitas sematan dokumen, Anda juga dapat menyertakan judul dengan menggunakan argumen prompt secara langsung:

    • Dengan judul:
    doc_embedding = model.encode(
    "The document text...",
    prompt="title: Using Prompts in RAG | text: "
)
    • Tanpa judul:
    doc_embedding = model.encode(
    "The document text...",
    prompt="title: none | text: "
)

Bacaan Lebih Lanjut

Klasifikasi

Klasifikasi adalah tugas menetapkan sepotong teks ke satu atau beberapa kategori atau label yang telah ditentukan. Ini adalah salah satu tugas paling mendasar dalam Natural Language Processing (NLP).

Aplikasi praktis klasifikasi teks adalah perutean tiket dukungan pelanggan. Proses ini secara otomatis mengarahkan kueri pelanggan ke departemen yang tepat, sehingga menghemat waktu dan mengurangi pekerjaan manual.

labels = ["Billing Issue", "Technical Support", "Sales Inquiry"]

sentence = [
  "Excuse me, the app freezes on the login screen. It won't work even when I try to reset my password.",
  "I would like to inquire about your enterprise plan pricing and features for a team of 50 people.",
]

# Calculate embeddings by calling model.encode()
label_embeddings = model.encode(labels, prompt_name="Classification")
embeddings = model.encode(sentence, prompt_name="Classification")

# Calculate the embedding similarities
similarities = model.similarity(embeddings, label_embeddings)
print(similarities)

idx = similarities.argmax(1)
print(idx)

for example in sentence:
  print("🙋‍♂️", example, "-> 🤖", labels[idx[sentence.index(example)]])

tensor([[0.4673, 0.5145, 0.3604],
        [0.4191, 0.5010, 0.5966]])
tensor([1, 2])
🙋‍♂️ Excuse me, the app freezes on the login screen. It won't work even when I try to reset my password. -> 🤖 Technical Support
🙋‍♂️ I would like to inquire about your enterprise plan pricing and features for a team of 50 people. -> 🤖 Sales Inquiry

Matryoshka Representation Learning (MRL)

EmbeddingGemma memanfaatkan MRL untuk menyediakan beberapa ukuran embedding dari satu model. Metode pelatihan ini sangat efektif karena menghasilkan satu embedding berkualitas tinggi dengan informasi paling penting yang terkonsentrasi di awal vektor.

Artinya, Anda bisa mendapatkan sematan yang lebih kecil, tetapi tetap sangat berguna, hanya dengan mengambil N dimensi pertama dari sematan lengkap. Penggunaan sematan yang lebih kecil dan dipangkas jauh lebih murah untuk disimpan dan lebih cepat diproses, tetapi efisiensi ini mengorbankan potensi kualitas sematan yang lebih rendah. MRL memberi Anda kemampuan untuk memilih keseimbangan optimal antara kecepatan dan akurasi ini untuk kebutuhan spesifik aplikasi Anda.

Mari kita gunakan tiga kata ["apple", "banana", "car"] dan buat embedding yang disederhanakan untuk melihat cara kerja MRL.

def check_word_similarities():
  # Calculate the embedding similarities
  print("similarity function: ", model.similarity_fn_name)
  similarities = model.similarity(embeddings[0], embeddings[1:])
  print(similarities)

  for idx, word in enumerate(words[1:]):
    print("🙋‍♂️ apple vs.", word, "-> 🤖 score: ", similarities.numpy()[0][idx])

# Calculate embeddings by calling model.encode()
embeddings = model.encode(words, prompt_name="STS")

check_word_similarities()

similarity function:  cosine
tensor([[0.7510, 0.6685]])
🙋‍♂️ apple vs. banana -> 🤖 score:  0.75102395
🙋‍♂️ apple vs. car -> 🤖 score:  0.6684626

Sekarang, untuk aplikasi yang lebih cepat, Anda tidak memerlukan model baru. Cukup potong sematan lengkap ke 512 dimensi pertama. Untuk hasil yang optimal, sebaiknya tetapkan juga normalize_embeddings=True, yang menskalakan vektor ke panjang unit 1.

embeddings = model.encode(words, truncate_dim=512, normalize_embeddings=True)

for idx, embedding in enumerate(embeddings):
  print(f"Embedding {idx+1}: {embedding.shape}")

print("-"*80)
check_word_similarities()

Embedding 1: (512,)
Embedding 2: (512,)
Embedding 3: (512,)
--------------------------------------------------------------------------------
similarity function:  cosine
tensor([[0.7674, 0.7041]])
🙋‍♂️ apple vs. banana -> 🤖 score:  0.767427
🙋‍♂️ apple vs. car -> 🤖 score:  0.7040509

Di lingkungan yang sangat terbatas, Anda dapat lebih mempersingkat penyematan menjadi hanya 256 dimensi. Anda juga dapat menggunakan produk titik yang lebih efisien untuk penghitungan kesamaan, bukan kesamaan kosinus standar.

model = SentenceTransformer(model_id, truncate_dim=256, similarity_fn_name="dot").to(device=device)
embeddings = model.encode(words, prompt_name="STS", normalize_embeddings=True)

for idx, embedding in enumerate(embeddings):
  print(f"Embedding {idx+1}: {embedding.shape}")

print("-"*80)
check_word_similarities()

Embedding 1: (256,)
Embedding 2: (256,)
Embedding 3: (256,)
--------------------------------------------------------------------------------
similarity function:  dot
tensor([[0.7855, 0.7382]])
🙋‍♂️ apple vs. banana -> 🤖 score:  0.7854644
🙋‍♂️ apple vs. car -> 🤖 score:  0.7382126

Ringkasan dan langkah selanjutnya

Sekarang Anda siap membuat embedding teks berkualitas tinggi menggunakan EmbeddingGemma dan library Sentence Transformers. Terapkan keterampilan ini untuk membangun fitur canggih seperti kesamaan semantik, klasifikasi teks, dan sistem Retrieval-Augmented Generation (RAG), serta terus jelajahi kemungkinan yang dapat dilakukan dengan model Gemma.

Selanjutnya, lihat dokumen berikut: