Veo 3 kini tersedia di Gemini API. Pelajari lebih lanjut

Halaman ini diterjemahkan oleh Cloud Translation API.

Embedding

Gemini API menawarkan model penyematan teks untuk menghasilkan penyematan kata, frasa, kalimat, dan kode. Sematan dasar ini mendukung tugas NLP lanjutan seperti penelusuran semantik, klasifikasi, dan pengelompokan, sehingga memberikan hasil yang lebih akurat dan sesuai konteks dibandingkan pendekatan berbasis kata kunci.

Membangun sistem Retrieval Augmented Generation (RAG) adalah kasus penggunaan umum untuk embedding. Penyematan memainkan peran penting dalam meningkatkan output model secara signifikan dengan akurasi faktual, koherensi, dan kekayaan kontekstual yang lebih baik. Mereka secara efisien mengambil informasi yang relevan dari pusat informasi, yang direpresentasikan oleh embedding, yang kemudian diteruskan sebagai konteks tambahan dalam perintah input ke model bahasa, sehingga memandunya untuk menghasilkan respons yang lebih berpengetahuan dan akurat.

Untuk mempelajari lebih lanjut varian model embedding yang tersedia, lihat bagian Versi model. Untuk aplikasi tingkat perusahaan dan workload bervolume tinggi, sebaiknya gunakan model embedding di Vertex AI.

Membuat embedding

Gunakan metode embedContent untuk membuat embedding teks:

Python

from google import genai

client = genai.Client()

result = client.models.embed_content(
        model="gemini-embedding-001",
        contents="What is the meaning of life?")

print(result.embeddings)

JavaScript

import { GoogleGenAI } from "@google/genai";

async function main() {

    const ai = new GoogleGenAI({});

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-001',
        contents: 'What is the meaning of life?',
    });

    console.log(response.embeddings);
}

main();

Go

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"

    "google.golang.org/genai"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    contents := []*genai.Content{
        genai.NewContentFromText("What is the meaning of life?", genai.RoleUser),
    }
    result, err := client.Models.EmbedContent(ctx,
        "gemini-embedding-001",
        contents,
        nil,
    )
    if err != nil {
        log.Fatal(err)
    }

    embeddings, err := json.MarshalIndent(result.Embeddings, "", "  ")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(string(embeddings))
}

REST

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:embedContent" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-d '{"model": "models/gemini-embedding-001",
     "content": {"parts":[{"text": "What is the meaning of life?"}]}
    }'

Anda juga dapat membuat sematan untuk beberapa potongan sekaligus dengan meneruskannya sebagai daftar string.

Python

from google import genai

client = genai.Client()

result = client.models.embed_content(
        model="gemini-embedding-001",
        contents= [
            "What is the meaning of life?",
            "What is the purpose of existence?",
            "How do I bake a cake?"
        ])

for embedding in result.embeddings:
    print(embedding)

JavaScript

import { GoogleGenAI } from "@google/genai";

async function main() {

    const ai = new GoogleGenAI({});

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-001',
        contents: [
            'What is the meaning of life?',
            'What is the purpose of existence?',
            'How do I bake a cake?'
        ],
    });

    console.log(response.embeddings);
}

main();

Go

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"

    "google.golang.org/genai"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    contents := []*genai.Content{
        genai.NewContentFromText("What is the meaning of life?"),
        genai.NewContentFromText("How does photosynthesis work?"),
        genai.NewContentFromText("Tell me about the history of the internet."),
    }
    result, err := client.Models.EmbedContent(ctx,
        "gemini-embedding-001",
        contents,
        nil,
    )
    if err != nil {
        log.Fatal(err)
    }

    embeddings, err := json.MarshalIndent(result.Embeddings, "", "  ")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(string(embeddings))
}

REST

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:embedContent" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-d '{"model": "models/gemini-embedding-001",
     "content": [
        {"parts": [{"text": "What is the meaning of life?"}]},
        {"parts": [{"text": "What is the purpose of existence?"}]},
        {"parts": [{"text": "How do I bake a cake?"}]}
        ]
    }'

Tentukan jenis tugas untuk meningkatkan performa

Anda dapat menggunakan embedding untuk berbagai tugas, mulai dari klasifikasi hingga penelusuran dokumen. Menentukan jenis tugas yang tepat akan membantu mengoptimalkan embedding untuk hubungan yang diinginkan, sehingga memaksimalkan akurasi dan efisiensi. Untuk mengetahui daftar lengkap jenis tugas yang didukung, lihat tabel Jenis tugas yang didukung.

Contoh berikut menunjukkan cara menggunakan SEMANTIC_SIMILARITY untuk memeriksa seberapa mirip makna string teks.

Python

from google import genai
from google.genai import types
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

client = genai.Client()

texts = [
    "What is the meaning of life?",
    "What is the purpose of existence?",
    "How do I bake a cake?"]

result = [
    np.array(e.values) for e in client.models.embed_content(
        model="gemini-embedding-001",
        contents=texts,
        config=types.EmbedContentConfig(task_type="SEMANTIC_SIMILARITY")).embeddings
]

# Calculate cosine similarity. Higher scores = greater semantic similarity.

embeddings_matrix = np.array(result)
similarity_matrix = cosine_similarity(embeddings_matrix)

for i, text1 in enumerate(texts):
    for j in range(i + 1, len(texts)):
        text2 = texts[j]
        similarity = similarity_matrix[i, j]
        print(f"Similarity between '{text1}' and '{text2}': {similarity:.4f}")

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as cosineSimilarity from "compute-cosine-similarity";

async function main() {
    const ai = new GoogleGenAI({});

    const texts = [
        "What is the meaning of life?",
        "What is the purpose of existence?",
        "How do I bake a cake?",
    ];

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-001',
        contents: texts,
        taskType: 'SEMANTIC_SIMILARITY'
    });

    const embeddings = response.embeddings.map(e => e.values);

    for (let i = 0; i < texts.length; i++) {
        for (let j = i + 1; j < texts.length; j++) {
            const text1 = texts[i];
            const text2 = texts[j];
            const similarity = cosineSimilarity(embeddings[i], embeddings[j]);
            console.log(`Similarity between '${text1}' and '${text2}': ${similarity.toFixed(4)}`);
        }
    }
}

main();

Go

package main

import (
    "context"
    "fmt"
    "log"
    "math"

    "google.golang.org/genai"
)

// cosineSimilarity calculates the similarity between two vectors.
func cosineSimilarity(a, b []float32) (float64, error) {
    if len(a) != len(b) {
        return 0, fmt.Errorf("vectors must have the same length")
    }

    var dotProduct, aMagnitude, bMagnitude float64
    for i := 0; i < len(a); i++ {
        dotProduct += float64(a[i] * b[i])
        aMagnitude += float64(a[i] * a[i])
        bMagnitude += float64(b[i] * b[i])
    }

    if aMagnitude == 0 || bMagnitude == 0 {
        return 0, nil
    }

    return dotProduct / (math.Sqrt(aMagnitude) * math.Sqrt(bMagnitude)), nil
}

func main() {
    ctx := context.Background()
    client, _ := genai.NewClient(ctx, nil)
    defer client.Close()

    texts := []string{
        "What is the meaning of life?",
        "What is the purpose of existence?",
        "How do I bake a cake?",
    }

    var contents []*genai.Content
    for _, text := range texts {
        contents = append(contents, genai.NewContentFromText(text, genai.RoleUser))
    }

    result, _ := client.Models.EmbedContent(ctx,
        "gemini-embedding-001",
        contents,
        &genai.EmbedContentRequest{TaskType: genai.TaskTypeSemanticSimilarity},
    )

    embeddings := result.Embeddings

    for i := 0; i < len(texts); i++ {
        for j := i + 1; j < len(texts); j++ {
            similarity, _ := cosineSimilarity(embeddings[i].Values, embeddings[j].Values)
            fmt.Printf("Similarity between '%s' and '%s': %.4f\n", texts[i], texts[j], similarity)
        }
    }
}

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:embedContent" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-d '{
    "contents": [
        {"parts": [{"text": "What is the meaning of life?"}]},
        {"parts": [{"text": "What is the purpose of existence?"}]},
        {"parts": [{"text": "How do I bake a cake?"}]}
    ],
    "embedding_config": {
        "task_type": "SEMANTIC_SIMILARITY"
    }
}'

Berikut contoh output dari cuplikan kode ini:

Similarity between 'What is the meaning of life?' and 'What is the purpose of existence?': 0.9481

Similarity between 'What is the meaning of life?' and 'How do I bake a cake?': 0.7471

Similarity between 'What is the purpose of existence?' and 'How do I bake a cake?': 0.7371

Jenis tugas yang didukung

Jenis tugas	Deskripsi	Contoh
SEMANTIC_SIMILARITY	Embedding dioptimalkan untuk menilai kemiripan teks.	Sistem rekomendasi, deteksi duplikat
KLASIFIKASI	Penyematan dioptimalkan untuk mengklasifikasikan teks menurut label preset.	Analisis sentimen, deteksi spam
PENGELOMPOKAN	Embedding dioptimalkan untuk mengelompokkan teks berdasarkan kesamaannya.	Pengaturan dokumen, riset pasar, deteksi anomali
RETRIEVAL_DOCUMENT	Embedding yang dioptimalkan untuk penelusuran dokumen.	Mengindeks artikel, buku, atau halaman web untuk penelusuran.
RETRIEVAL_QUERY	Penyematan yang dioptimalkan untuk kueri penelusuran umum. Gunakan `RETRIEVAL_QUERY` untuk kueri; `RETRIEVAL_DOCUMENT` untuk dokumen yang akan diambil.	Penelusuran khusus
CODE_RETRIEVAL_QUERY	Embedding yang dioptimalkan untuk pengambilan blok kode berdasarkan kueri bahasa alami. Gunakan `CODE_RETRIEVAL_QUERY` untuk kueri; `RETRIEVAL_DOCUMENT` untuk blok kode yang akan diambil.	Saran dan penelusuran kode
QUESTION_ANSWERING	Penyematan untuk pertanyaan dalam sistem tanya jawab, yang dioptimalkan untuk menemukan dokumen yang menjawab pertanyaan. Gunakan `QUESTION_ANSWERING` untuk pertanyaan; `RETRIEVAL_DOCUMENT` untuk dokumen yang akan diambil.	Kotak chat
FACT_VERIFICATION	Penyematan untuk pernyataan yang perlu diverifikasi, dioptimalkan untuk mengambil dokumen yang berisi bukti yang mendukung atau menyangkal pernyataan tersebut. Gunakan `FACT_VERIFICATION` untuk teks target; `RETRIEVAL_DOCUMENT` untuk dokumen yang akan diambil	Sistem pengecekan fakta otomatis

Mengontrol ukuran penyematan

Model penyematan Gemini, gemini-embedding-001, dilatih menggunakan teknik Matryoshka Representation Learning (MRL) yang mengajarkan model untuk mempelajari penyematan berdimensi tinggi yang memiliki segmen awal (atau awalan) yang juga merupakan versi data yang sama yang berguna dan lebih sederhana.

Gunakan parameter output_dimensionality untuk mengontrol ukuran vektor sematan output. Memilih dimensi output yang lebih kecil dapat menghemat ruang penyimpanan dan meningkatkan efisiensi komputasi untuk aplikasi hilir, sekaligus sedikit mengorbankan kualitas. Secara default, model ini menghasilkan embedding 3072 dimensi, tetapi Anda dapat memangkasnya ke ukuran yang lebih kecil tanpa mengurangi kualitas untuk menghemat ruang penyimpanan. Sebaiknya gunakan dimensi output 768, 1536, atau 3072.

Python

from google import genai
from google.genai import types

client = genai.Client()

result = client.models.embed_content(
    model="gemini-embedding-001",
    contents="What is the meaning of life?",
    config=types.EmbedContentConfig(output_dimensionality=768)
)

[embedding_obj] = result.embeddings
embedding_length = len(embedding_obj.values)

print(f"Length of embedding: {embedding_length}")

JavaScript

import { GoogleGenAI } from "@google/genai";

async function main() {
    const ai = new GoogleGenAI({});

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-001',
        content: 'What is the meaning of life?',
        outputDimensionality: 768,
    });

    const embeddingLength = response.embedding.values.length;
    console.log(`Length of embedding: ${embeddingLength}`);
}

main();

Go

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
)

func main() {
    ctx := context.Background()
    // The client uses Application Default Credentials.
    // Authenticate with 'gcloud auth application-default login'.
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }
    defer client.Close()

    contents := []*genai.Content{
        genai.NewContentFromText("What is the meaning of life?", genai.RoleUser),
    }

    result, err := client.Models.EmbedContent(ctx,
        "gemini-embedding-001",
        contents,
        &genai.EmbedContentRequest{OutputDimensionality: 768},
    )
    if err != nil {
        log.Fatal(err)
    }

    embedding := result.Embeddings[0]
    embeddingLength := len(embedding.Values)
    fmt.Printf("Length of embedding: %d\n", embeddingLength)
}

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:embedContent" \
-H "x-goog-api-key: YOUR_GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-d '{
    "contents": [
        {"parts": [{"text": "What is the meaning of life?"}]}
    ],
    "embedding_config": {
        "output_dimensionality": 768
    }
}'

Contoh output dari cuplikan kode:

Length of embedding: 768

Memastikan kualitas untuk dimensi yang lebih kecil

Embedding 3072 dimensi dinormalisasi. Embedding yang dinormalisasi menghasilkan kemiripan semantik yang lebih akurat dengan membandingkan arah vektor, bukan besarnya. Untuk dimensi lain, termasuk 768 dan 1536, Anda perlu menormalisasi sematan sebagai berikut:

Python

import numpy as np
from numpy.linalg import norm

embedding_values_np = np.array(embedding_obj.values)
normed_embedding = embedding_values_np / np.linalg.norm(embedding_values_np)

print(f"Normed embedding length: {len(normed_embedding)}")
print(f"Norm of normed embedding: {np.linalg.norm(normed_embedding):.6f}") # Should be very close to 1

Contoh output dari cuplikan kode ini:

Normed embedding length: 768
Norm of normed embedding: 1.000000

Tabel berikut menunjukkan skor MTEB, tolok ukur yang umum digunakan untuk embedding, untuk dimensi yang berbeda. Khususnya, hasilnya menunjukkan bahwa performa tidak terikat secara ketat dengan ukuran dimensi embedding, dengan dimensi yang lebih rendah mencapai skor yang sebanding dengan dimensi yang lebih tinggi.

Dimensi MRL	Skor MTEB
2048	68.16
1536	68,17
768	67,99
512	67,55
256	66,19
128	63,31

Kasus penggunaan

Embedding teks sangat penting untuk berbagai kasus penggunaan AI umum, seperti:

Retrieval-Augmented Generation (RAG): Embedding meningkatkan kualitas teks yang dihasilkan dengan mengambil dan menggabungkan informasi yang relevan ke dalam konteks model.
Pengambilan informasi: Menelusuri teks atau dokumen yang paling mirip secara semantik dengan input teks tertentu.

Tutorial penelusuran dokumen
Pengurutan ulang penelusuran: Memprioritaskan item yang paling relevan dengan memberi skor semantik pada hasil awal terhadap kueri.

Tutorial penyesuaian peringkat penelusuran
Deteksi anomali: Membandingkan grup embedding dapat membantu mengidentifikasi tren atau pencilan tersembunyi.

Tutorial deteksi anomali
Klasifikasi: Mengategorikan teks secara otomatis berdasarkan kontennya, seperti analisis sentimen atau deteksi spam

Tutorial klasifikasi
Pengelompokan: Pahami hubungan yang kompleks secara efektif dengan membuat cluster dan visualisasi embedding Anda.

Tutorial visualisasi pengelompokan

Menyimpan embedding

Saat Anda menggunakan embedding untuk produksi, biasanya Anda akan menggunakan database vektor untuk menyimpan, mengindeks, dan mengambil embedding berdimensi tinggi secara efisien. Google Cloud menawarkan layanan data terkelola yang dapat digunakan untuk tujuan ini, termasuk BigQuery, AlloyDB, dan Cloud SQL.

Tutorial berikut menunjukkan cara menggunakan database vektor pihak ketiga lainnya dengan Gemini Embedding.

Versi model

Properti	Deskripsi
Kode model	Gemini API `gemini-embedding-001`
Jenis data yang didukung	Input Teks Output Embedding teks
Batas token^[*]	Batas token input 2.048 Ukuran dimensi output Fleksibel, mendukung: 128 - 3072, Direkomendasikan: 768, 1536, 3072
Versi	Baca pola versi model untuk mengetahui detail selengkapnya. Stabil: `gemini-embedding-001` Eksperimental: `gemini-embedding-exp-03-07`
Pembaruan terbaru	Juni 2025

Pemberitahuan penggunaan yang bertanggung jawab

Tidak seperti model AI generatif yang membuat konten baru, model Embedding Gemini hanya ditujukan untuk mengubah format data input Anda menjadi representasi numerik. Meskipun Google bertanggung jawab untuk menyediakan model penyematan yang mengubah format data input Anda ke format numerik yang diminta, pengguna tetap bertanggung jawab sepenuhnya atas data yang mereka masukkan dan penyematan yang dihasilkan. Dengan menggunakan model Embedding Gemini, Anda mengonfirmasi bahwa Anda memiliki hak yang diperlukan atas konten apa pun yang Anda upload. Jangan membuat konten yang melanggar hak atas kekayaan intelektual atau hak privasi orang lain. Penggunaan layanan ini oleh Anda tunduk pada Kebijakan Penggunaan Terlarang dan Persyaratan Layanan Google kami.

Mulai membangun dengan embedding

Lihat notebook panduan memulai embedding untuk mempelajari kemampuan model dan cara menyesuaikan serta memvisualisasikan embedding.