Wektory dystrybucyjne

Gemini API udostępnia modele wektorów dystrybucyjnych tekstu, które generują wektory dystrybucyjne dla słów, fraz, zdań i kodu. Zadania związane z osadzaniem, takie jak wyszukiwanie semantyczne, klasyfikacja i grupowanie, które zapewniają dokładniejsze wyniki uwzględniające kontekst niż podejścia oparte na słowach kluczowych.

Tworzenie systemów generowania rozszerzonego przez wyszukiwanie w zapisanych informacjach (RAG) jest typowym zastosowaniem usług AI. Osadzanie odgrywa kluczową rolę w znacznym ulepszaniu wyników modelu dzięki większej dokładności, spójności i bogactwu kontekstowemu. Jeśli wolisz korzystać z zarządzanego rozwiązania RAG, stworzyliśmy narzędzie Wyszukiwanie plików, które ułatwia zarządzanie RAG i obniża jego koszty.

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

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 "Content-Type: application/json" \
    -H "x-goog-api-key: ${GEMINI_API_KEY}" \
    -d '{
        "model": "models/gemini-embedding-001",
        "content": {
        "parts": [{
            "text": "What is the meaning of life?"
        }]
        }
    }'

Możesz też wygenerować osadzanie 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();

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 "Content-Type: application/json" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -d '{
    "content": {
        "parts": [
        {
            "text": "What is the meaning of life?"
        },
        {
            "text": "How much wood would a woodchuck chuck?"
        },
        {
            "text": "How does the brain work?"
        }
        ]
    },
    "taskType": "SEMANTIC_SIMILARITY"
    }'

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 zoptymalizować 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 znaczeniowo ciągi tekstów.

Python

from google import genai
from google.genai import types
import pandas as pd
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 = client.models.embed_content(
    model="gemini-embedding-001",
    contents=texts,
    config=types.EmbedContentConfig(task_type="SEMANTIC_SIMILARITY")
)

# Create a 3x3 table to show the similarity matrix
df = pd.DataFrame(
    cosine_similarity([e.values for e in result.embeddings]),
    index=texts,
    columns=texts,
)

print(df)

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 "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:embedContent" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -d '{
    "taskType": "SEMANTIC_SIMILARITY",
    "content": {
        "parts": [
        {
            "text": "What is the meaning of life?"
        },
        {
            "text": "How much wood would a woodchuck chuck?"
        },
        {
            "text": "How does the brain work?"
        }
        ]
    }
    }'

Fragmenty kodu pokażą, jak podobne są do siebie różne części tekstu po uruchomieniu.

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.	Porządkowanie 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żywaj symbolu `QUESTION_ANSWERING` w przypadku pytań, a symbolu `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 Matrioszki (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 podrzędnych, przy niewielkim pogorszeniu jakości. Domyślnie generuje on 3072-wymiarowe osadzenie, ale możesz je skrócić do mniejszego rozmiaru bez utraty jakości, aby zaoszczędzić miejsce na dane. 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();

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 'Content-Type: application/json' \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -d '{
        "content": {"parts":[{ "text": "What is the meaning of life?"}]},
        "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 dzięki porównywaniu kierunku wektora, a nie jego wielkości. 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 wydajność nie jest ściśle związana z rozmiarem wymiaru osadzania, ponieważ mniejsze wymiary osiągają wyniki porównywalne z większymi.

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:

Generowanie rozszerzone przez wyszukiwanie w zapisanych informacjach (RAG): osadzanie poprawia jakość wygenerowanego tekstu, ponieważ wyszukuje i uwzględnia w kontekście modelu odpowiednie informacje.
Wyszukiwanie informacji: wyszukiwanie najbardziej podobnego semantycznie tekstu lub dokumentów na podstawie podanego tekstu.

Samouczek dotyczący wyszukiwania dokumentów
Ponowne rankingowanie wyników wyszukiwania: priorytetyzowanie najtrafniejszych elementów przez semantyczne ocenianie wstępnych wyników pod kątem zapytania.

Samouczek dotyczący ponownego rankingu wyników wyszukiwania
Wykrywanie anomalii: porównywanie grup wektorów może pomóc w identyfikowaniu ukrytych trendów lub wartości odstających.

Samouczek dotyczący wykrywania anomalii
Klasyfikacja: automatyczne kategoryzowanie tekstu na podstawie jego treści, np. analiza nastawienia lub wykrywanie spamu.

Samouczek dotyczący klasyfikacji
Klastrowanie: skutecznie poznawaj złożone relacje, tworząc klastry i wizualizacje osadzeń.

Samouczek dotyczący wizualizacji klastrowania

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 z zakresu 128–3072. Zalecane wartości: 768, 1536, 3072.
Wersje	Więcej informacji znajdziesz w wzorcach wersji modelu. Stabilny: `gemini-embedding-001`
Ostatnia aktualizacja	Czerwiec 2025 r.

W przypadku wycofanych modeli Embeddings odwiedź stronę Wycofane modele.

Wektory dystrybucyjne zbiorcze

Jeśli opóźnienie nie jest problemem, spróbuj użyć modelu Gemini Embeddings z interfejsem Batch API. Umożliwia to znacznie większą przepustowość przy 50% domyślnej ceny za osadzanie. Przykłady, jak zacząć, znajdziesz w przewodniku po interfejsie Batch API.

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ę liczbową. 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 wprowadzane dane i powstałe osadzanie. 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.