Wektory dystrybucyjne

Gemini API udostępnia modele wektorów dystrybucyjnych tekstu, które generują wektory dystrybucyjne dla słów, fraz, zdań i kodu. Te podstawowe wektory dystrybucyjne umożliwiają wykonywanie zaawansowanych zadań NLP, takich jak wyszukiwanie semantyczne, klasyfikacja i grupowanie, dzięki czemu zapewniają dokładniejsze wyniki uwzględniające kontekst niż podejścia oparte na słowach kluczowych.

Tworzenie systemów generowania wspomaganego wyszukiwaniem (RAG) to typowy przypadek użycia osadzania. Osadzanie odgrywa kluczową rolę w znacznym ulepszaniu wyników modelu dzięki zwiększeniu dokładności faktów, spójności i bogactwa kontekstowego. Skutecznie pobierają one odpowiednie informacje z baz wiedzy reprezentowanych przez wektory, które są następnie przekazywane jako dodatkowy kontekst w prompcie wejściowym do modeli językowych, co pomaga im generować bardziej trafne i dokładne odpowiedzi.

Więcej informacji o dostępnych wariantach modelu wektorów dystrybucyjnych znajdziesz w sekcji Wersje modelu. W przypadku aplikacji klasy korporacyjnej i zbiorów zadań o dużej ilości danych zalecamy używanie modeli wektorów dystrybucyjnych w Vertex AI.

Generowanie wektorów dystrybucyjnych

Aby wygenerować osadzanie tekstu, użyj metody embedContent:

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();

Przeczytaj

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?"}]}
    }'

Możesz też wygenerować wektory osadzania dla wielu fragmentów naraz, przekazując je jako listę ciągów znaków.

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();

Przeczytaj

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?"}]}
        ]
    }'

Określ typ zadania, które ma poprawić skuteczność

Możesz używać wektorów do wielu różnych zadań, od klasyfikacji po wyszukiwanie dokumentów. Określenie właściwego typu zadania pomaga optymalizować osadzanie pod kątem zamierzonych relacji, co zwiększa dokładność i wydajność. Pełną listę obsługiwanych typów zadań znajdziesz w tabeli Obsługiwane typy zadań.

Przykład poniżej pokazuje, jak za pomocą funkcji SEMANTIC_SIMILARITY sprawdzić, jak podobne są do siebie ciągi tekstów.

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();

Przeczytaj

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"
    }
}'

Poniżej znajdziesz przykładowe dane wyjściowe tego fragmentu kodu:

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

Obsługiwane typy zadań

Typ zadania Opis Przykłady
SEMANTIC_SIMILARITY Osadzanie zoptymalizowane pod kątem oceny podobieństwa tekstu. Systemy rekomendacji, wykrywanie duplikatów
KLASYFIKACJA Osadzanie zoptymalizowane pod kątem klasyfikowania tekstów według wstępnie ustawionych etykiet. Analiza nastawienia, wykrywanie spamu
KLASYFIKACJA Osadzanie zoptymalizowane pod kątem grupowania tekstów na podstawie ich podobieństw. organizowanie dokumentów, badania rynku, wykrywanie anomalii;
RETRIEVAL_DOCUMENT Osadzanie zoptymalizowane pod kątem wyszukiwania dokumentów. indeksowanie artykułów, książek lub stron internetowych na potrzeby wyszukiwania;
RETRIEVAL_QUERY Osadzanie zoptymalizowane pod kątem ogólnych zapytań. Używaj symbolu RETRIEVAL_QUERY w przypadku zapytań, a symbolu RETRIEVAL_DOCUMENT w przypadku dokumentów do pobrania. Twoja wyszukiwarka
CODE_RETRIEVAL_QUERY Osadzanie zoptymalizowane pod kątem wyszukiwania bloków kodu na podstawie zapytań w języku naturalnym. Używaj znaku CODE_RETRIEVAL_QUERY w przypadku zapytań, a znaku RETRIEVAL_DOCUMENT w przypadku bloków kodu, które mają zostać pobrane. Sugestie dotyczące kodu i wyszukiwanie
QUESTION_ANSWERING Osadzanie pytań w systemie odpowiadania na pytania, zoptymalizowane pod kątem znajdowania dokumentów, które zawierają odpowiedź na pytanie. Użyj QUESTION_ANSWERING w przypadku pytań i RETRIEVAL_DOCUMENT w przypadku dokumentów do pobrania. Chatbox
FACT_VERIFICATION Osadzenia dla stwierdzeń, które wymagają weryfikacji, zoptymalizowane pod kątem wyszukiwania dokumentów zawierających dowody potwierdzające lub obalające to stwierdzenie. Użyj FACT_VERIFICATION w przypadku tekstu docelowego, a RETRIEVAL_DOCUMENT w przypadku dokumentów do pobrania. Automatyczne systemy weryfikacji informacji

Określanie rozmiaru wektora dystrybucyjnego

Model osadzania Gemini gemini-embedding-001 jest trenowany przy użyciu techniki uczenia reprezentacji Matrioszka (MRL), która uczy model tworzenia osadzania o wysokim wymiarze, które mają początkowe segmenty (lub prefiksy) będące również przydatnymi, prostszymi wersjami tych samych danych.

Użyj parametru output_dimensionality, aby kontrolować rozmiar wyjściowego wektora osadzania. Wybór mniejszej liczby wymiarów wyjściowych może zaoszczędzić miejsce na dane i zwiększyć wydajność obliczeniową w przypadku aplikacji niższego poziomu, przy niewielkiej utracie jakości. Domyślnie generuje on 3072-wymiarowe osadzenie, ale możesz je skrócić, aby zaoszczędzić miejsce na dane, bez utraty jakości. Zalecamy używanie wymiarów wyjściowych 768, 1536 lub 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();

Przeczytaj

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
    }
}'

Przykładowe dane wyjściowe z fragmentu kodu:

Length of embedding: 768

Zapewnianie jakości w przypadku mniejszych wymiarów

Wektor dystrybucyjny o wymiarze 3072 jest znormalizowany. Znormalizowane wektory dystrybucyjne zapewniają większą dokładność podobieństwa semantycznego, ponieważ porównują kierunek wektora, a nie jego wielkość. W przypadku innych wymiarów, w tym 768 i 1536, musisz znormalizować osadzanie w ten sposób:

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

Przykładowe dane wyjściowe tego fragmentu kodu:

Normed embedding length: 768
Norm of normed embedding: 1.000000

W tabeli poniżej znajdziesz wyniki MTEB, czyli powszechnie stosowanego testu porównawczego dla osadzania, dla różnych wymiarów. Wyniki pokazują, że skuteczność nie jest ściśle związana z rozmiarem wymiaru osadzania. Wymiary o mniejszej liczbie elementów osiągają wyniki porównywalne z wymiarami o większej liczbie elementów.

Wymiar MRL Wynik MTEB
2048 68,16
1536 68,17
768 67,99
512 67,55
256 66,19
128 63,31

Przypadki użycia

Osadzanie tekstu ma kluczowe znaczenie w przypadku wielu typowych zastosowań AI, takich jak:

Przechowywanie wektorów dystrybucyjnych

W przypadku wdrażania wektorów dystrybucyjnych w środowisku produkcyjnym często używa się baz danych wektorowych do wydajnego przechowywania, indeksowania i pobierania wektorów dystrybucyjnych o wysokiej liczbie wymiarów. Google Cloud oferuje zarządzane usługi danych, które można wykorzystać w tym celu, w tym BigQuery, AlloyDB i Cloud SQL.

Z tych samouczków dowiesz się, jak używać innych baz danych wektorów innych firm z osadzaniem Gemini.

Wersje modelu

Właściwość Opis
Kod modelu

Gemini API

gemini-embedding-001
Obsługiwane typy danych

Wejście

Tekst

Dane wyjściowe

Wektory dystrybucyjne tekstu
Limity tokenów[*]

Limit tokenów wejściowych

2048

Rozmiar wymiaru wyjściowego

Elastyczny, obsługuje wartości od 128 do 3072. Zalecane wartości: 768, 1536, 3072.
Wersje
Więcej informacji znajdziesz w wzorcach wersji modelu.
  • Stabilny: gemini-embedding-001
  • Eksperymentalne: gemini-embedding-exp-03-07
Ostatnia aktualizacja Czerwiec 2025 r.

Powiadomienie o odpowiedzialnym korzystaniu

W przeciwieństwie do modeli generatywnej AI, które tworzą nowe treści, model Gemini Embedding ma tylko przekształcać format danych wejściowych w reprezentację numeryczną. Google odpowiada za udostępnienie modelu osadzania, który przekształca format danych wejściowych na wymagany format numeryczny, ale użytkownicy ponoszą pełną odpowiedzialność za dane, które wprowadzają, oraz za wynikające z nich osadzania. Korzystając z modelu Gemini Embedding, potwierdzasz, że masz wymagane prawa do treści, które przesyłasz. Nie twórz treści naruszających prawa własności intelektualnej lub prawo do prywatności innych osób. Korzystanie z tej usługi podlega naszym Zasadom dotyczącym niedozwolonych zastosowań i Warunkom korzystania z usług Google.

Zacznij tworzyć z użyciem wektorów

Zapoznaj się z notebookiem z krótkim wprowadzeniem do osadzania, aby poznać możliwości modelu i dowiedzieć się, jak dostosowywać i wizualizować osadzanie.