Wektory dystrybucyjne

Gemini API oferuje modele wektorów dystrybucyjnych do generowania wektorów dystrybucyjnych tekstu, obrazów, filmów i innych treści. Te wektory dystrybucyjne można następnie wykorzystać do zadań takich jak wyszukiwanie semantyczne, klasyfikacja i grupowanie, co pozwala uzyskać dokładniejsze, dopasowane kontekstowo wyniki niż w przypadku podejścia opartego na słowach kluczowych.

Najnowszy model, gemini-embedding-2, jest pierwszym multimodalnym modelem wektorów dystrybucyjnych w interfejsie Gemini API. Mapuje tekst, obrazy, filmy, dźwięk i dokumenty na ujednoliconą przestrzeń wektorów dystrybucyjnych, umożliwiając wyszukiwanie, klasyfikowanie i grupowanie w ponad 100 językach. Więcej informacji znajdziesz w sekcji dotyczącej wektorów dystrybucyjnych multimodalnych. W przypadkach użycia obejmujących tylko tekst model gemini-embedding-001 pozostaje dostępny.

Tworzenie systemów generowania wspomaganego wyszukiwaniem (RAG) to typowy przypadek użycia usług AI. Wektory dystrybucyjne odgrywają kluczową rolę w znacznym ulepszaniu danych wyjściowych modelu, zwiększając ich dokładność, spójność i bogactwo kontekstowe. 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 jest bardziej opłacalne.

Generowanie wektorów dystrybucyjnych

Aby wygenerować wektory dystrybucyjne tekstu, użyj metody embedContent:

Python

from google import genai

client = genai.Client()

result = client.models.embed_content(
        model="gemini-embedding-2",
        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-2',
        contents: 'What is the meaning of life?',
    });

    console.log(response.embeddings);
}

main();

Java

import com.google.genai.Client;
import com.google.genai.types.EmbedContentResponse;

Client client = new Client();

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", "What is the meaning of life?", null);

System.out.println(response.embeddings().orElse(null));

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

Określanie typu zadania w celu zwiększenia skuteczności

Możesz używać wektorów dystrybucyjnych do wielu różnych zadań, od klasyfikacji po wyszukiwanie dokumentów. Określenie właściwego typu zadania pomaga zoptymalizować wektory dystrybucyjne pod kątem zamierzonych relacji, co maksymalizuje dokładność i wydajność.

Typy zadań z wektorami dystrybucyjnymi 2

W przypadku zadań tekstowych z gemini-embedding-2 zdecydowanie zalecamy dodanie instrukcji zadania w prompcie. Można to zrobić, formatując zapytanie i dokument za pomocą prawidłowego prefiksu zadania.

Podczas generowania pojedynczego wektora dystrybucyjnego na podstawie danych multimodalnych zwykle nie zalecamy dodawania instrukcji zadania przed tekstową częścią danych wejściowych. W niektórych przypadkach poprawia to wydajność, ale w innych ją obniża.

W tabelach poniżej znajdziesz przykłady formatowania zapytań i dokumentów w przypadku symetrycznych i asymetrycznych przypadków użycia modelu gemini-embedding-2.

Przypadki użycia związane z pobieraniem (format asymetryczny)

W przypadku asymetrycznych zastosowań dodaj do zapytania prefiks zadania i zastosuj strukturę dokumentu do treści, które chcesz umieścić i pobrać.

Przypadek użycia Struktura zapytania Struktura dokumentu
Zapytanie task: search result | query: {content} title: {title} | text: {content}
Jeśli nie ma tytułu, użyj title: none.
Odpowiadanie na pytania task: question answering | query: {content} title: {title} | text: {content}
Informacje zweryfikowane task: fact checking | query: {content} title: {title} | text: {content}
Pobieranie kodu task: code retrieval | query: {content} title: {title} | text: {content}

Przykładowe zastosowanie

Python

# Generate embedding for a task's query. Use your correct task here:
def prepare_query(query):
    # return f"task: question answering | query: {query}"
    # return f"task: fact checking | query: {query}"
    # return f"task: code retrieval | query: {query}"
    return f"task: search result | query: {query}"

# Generate embedding for document of an asymmetric retrieval task:
def prepare_document(content, title=None):
    if title is None:
        title = "none"
    return f"title: {title} | text: {content}"

Przypadki użycia z jednymi danymi wejściowymi (format symetryczny)

W przypadkach symetrycznych używaj tego samego formatowania zapytania i dokumentu w ramach tego samego zadania.

Przypadek użycia Struktura danych wejściowych
Klasyfikacja task: classification | query: {content}
Grupowanie task: clustering | query: {content}
Podobieństwo semantyczne task: sentence similarity | query: {content}
Nie używaj tego do wyszukiwania ani pobierania. Jest przeznaczony do semantycznego podobieństwa tekstowego.

Przykładowe zastosowanie

Python

# Generate embedding for query & document of your task.
def prepare_query_and_document(content):
    # return f'task: clustering | query: {content}'
    # return f'task: sentence similarity | query: {content}'
    return f'task: classification | query: {content}'

Ważne jest, aby zadanie było używane konsekwentnie. Jeśli na przykład dokumenty są umieszczone za pomocą f'task: classification | query: {content}', zapytanie również powinno być umieszczone zgodnie z tym formatem zadania.

Typy zadań z wektorami dystrybucyjnymi 1

W przypadku gemini-embedding-001 możesz określić task_type w metodzie embedContent. Pełną listę obsługiwanych typów zadań znajdziesz w tabeli Obsługiwane typy zadań.

Poniższy przykład pokazuje, jak za pomocą funkcji SEMANTIC_SIMILARITY sprawdzić, jak podobne są znaczenia ciągów tekstowych.

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";
// npm i compute-cosine-similarity
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,
        config: { 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();

Java

import java.util.Arrays;
import com.google.genai.Client;
import com.google.genai.types.ContentEmbedding;
import com.google.genai.types.EmbedContentConfig;
import com.google.genai.types.EmbedContentResponse;
import java.util.List;

Client client = new Client();

List<String> texts =
    Arrays.asList(
        "What is the meaning of life?",
        "What is the purpose of existence?",
        "How do I bake a cake?");

EmbedContentConfig config =
    EmbedContentConfig.builder().taskType("SEMANTIC_SIMILARITY").build();

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-001", texts, config);

List<ContentEmbedding> embeddings = response.embeddings().get();

for (int i = 0; i < texts.size(); i++) {
  for (int j = i + 1; j < texts.size(); j++) {
    List<Float> v1 = embeddings.get(i).values().get();
    List<Float> v2 = embeddings.get(j).values().get();
    double dotProduct = 0.0;
    double normA = 0.0;
    double normB = 0.0;
    for (int k = 0; k < v1.size(); k++) {
      dotProduct += v1.get(k) * v2.get(k);
      normA += v1.get(k) * v1.get(k);
      normB += v2.get(k) * v2.get(k);
    }
    double similarity = dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
    System.out.printf(
        "Similarity between '%s' and '%s': %.4f%n", texts.get(i), texts.get(j), similarity);
  }
}

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 pokazują, jak podobne są do siebie różne fragmenty tekstu po uruchomieniu.

Obsługiwane typy zadań

Obsługiwane typy zadań w przypadku gemini-embedding-001:

Typ zadania Opis Przykłady
SEMANTIC_SIMILARITY Wektory dystrybucyjne zoptymalizowane pod kątem oceny podobieństwa tekstu. Systemy rekomendacji, wykrywanie duplikatów
CLASSIFICATION Wektory dystrybucyjne zoptymalizowane pod kątem klasyfikowania tekstów według wstępnie ustawionych etykiet. analiza nastawienia, wykrywanie spamu;
CLUSTERING Wektory dystrybucyjne zoptymalizowane pod kątem grupowania tekstów na podstawie ich podobieństw. Porządkowanie dokumentów, badanie rynku, wykrywanie anomalii
RETRIEVAL_DOCUMENT Wektory dystrybucyjne zoptymalizowane pod kątem wyszukiwania dokumentów. indeksowanie artykułów, książek lub stron internetowych na potrzeby wyszukiwania;
RETRIEVAL_QUERY Wektory dystrybucyjne zoptymalizowane pod kątem ogólnych zapytań. Użyj RETRIEVAL_QUERY w przypadku zapytań i RETRIEVAL_DOCUMENT w przypadku dokumentów do pobrania. Twoja wyszukiwarka
CODE_RETRIEVAL_QUERY Wektory dystrybucyjne zoptymalizowane pod kątem pobierania bloków kodu na podstawie zapytań w języku naturalnym. Używaj CODE_RETRIEVAL_QUERY w przypadku zapytań i RETRIEVAL_DOCUMENT w przypadku bloków kodu do pobrania. Sugestie dotyczące kodu i wyszukiwanie
QUESTION_ANSWERING Wektory dystrybucyjne pytań w systemie pytań i odpowiedzi, zoptymalizowane pod kątem znajdowania dokumentów, które odpowiadają na pytanie. Użyj QUESTION_ANSWERING w przypadku pytań i RETRIEVAL_DOCUMENT w przypadku dokumentów do pobrania. Chatbox
FACT_VERIFICATION Wektory dystrybucyjne dla stwierdzeń, które należy zweryfikować, zoptymalizowane pod kątem pobierania dokumentów zawierających dowody potwierdzające lub obalające stwierdzenie. Użyj FACT_VERIFICATION w przypadku tekstu docelowego i RETRIEVAL_DOCUMENT w przypadku dokumentów do pobrania Zautomatyzowane systemy weryfikacji informacji

Kontrolowanie rozmiaru wektora dystrybucyjnego

Zarówno gemini-embedding-001, jak i gemini-embedding-2 są trenowane przy użyciu techniki uczenia się reprezentacji Matryoshka (MRL), która uczy model rozpoznawania wysokowymiarowych wektorów dystrybucyjnych, 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 dystrybucyjnego. Wybór mniejszego wymiaru danych wyjściowych może zaoszczędzić miejsce na dane i zwiększyć wydajność obliczeniową aplikacji, które korzystają z tych danych, przy niewielkim spadku jakości. Domyślnie oba modele generują wektory dystrybucyjne o 3072 wymiarach, ale możesz je skrócić do mniejszego rozmiaru bez utraty jakości, aby zaoszczędzić miejsce na dane. Zalecamy użycie 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-2",
    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-2',
        contents: 'What is the meaning of life?',
        config: { outputDimensionality: 768 },
    });

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

main();

Java

import com.google.genai.Client;
import com.google.genai.types.ContentEmbedding;
import com.google.genai.types.EmbedContentConfig;
import com.google.genai.types.EmbedContentResponse;

Client client = new Client();

EmbedContentConfig config =
    EmbedContentConfig.builder().outputDimensionality(768).build();

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", "What is the meaning of life?", config);

ContentEmbedding embeddingObj = response.embeddings().get().get(0);
int embeddingLength = embeddingObj.values().get().size();

System.out.println("Length of embedding: " + embeddingLength);

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-2",
        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-2: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

Domyślne wektory dystrybucyjne o 3072 wymiarach są zawsze normalizowane, ale Gemini Embedding 2 automatycznie normalizuje też obcięte wymiary (np. 768, 1536). Dzięki temu podobieństwo semantyczne jest obliczane na podstawie kierunku wektora, a nie jego wielkości, co zapewnia dokładniejsze wyniki od razu po uruchomieniu.

Starsze modele: jeśli używasz modelu gemini-embedding-001, musisz ręcznie znormalizować wymiary inne niż 3072 w następujący sposób:

Python

import numpy as np
from numpy.linalg import norm

# Only for embeddings from `gemini-embedding-001`
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 z tego fragmentu kodu:

Normed embedding length: 768
Norm of normed embedding: 1.000000

W tabeli poniżej znajdziesz wyniki MTEB, czyli powszechnie używanego testu porównawczego wektorów dystrybucyjnych, dla różnych wymiarów. Wyniki pokazują, że wydajność nie jest ściśle powiązana z rozmiarem wymiaru wektora dystrybucyjnego, ponieważ niższe wymiary osiągają wyniki porównywalne z ich odpowiednikami o wyższych wymiarach.

Wymiar MRL Wynik MTEB (Gemini Embedding 001)
2048 68.16
1536 68,17
768 67,99
512 67,55
256 66,19
128 63,31

Multimodalne wektory dystrybucyjne

Model gemini-embedding-2 obsługuje multimodalne dane wejściowe, co umożliwia umieszczanie obrazów, filmów, dźwięku i dokumentów obok tekstu. Wszystkie modalności są mapowane na tę samą przestrzeń wektorów dystrybucyjnych, co umożliwia wyszukiwanie i porównywanie między modalnościami.

Obsługiwane modalności i limity

Ogólny maksymalny limit tokenów wejściowych to 8192 tokeny.

Modalność Specyfikacje i limity
Text Obsługuje do 8192 tokenów.
Obraz Maksymalnie 6 obrazów na żądanie. Obsługiwane formaty: PNG, JPEG.
Dźwięk Maksymalny czas trwania: 180 sekund. Obsługiwane formaty: MP3, WAV.
Film Maksymalny czas trwania: 120 sekund. Obsługiwane formaty: MP4, MOV. Obsługiwane kodeki: H264, H265, AV1, VP9.
System przetwarza maksymalnie 32 klatki na film: krótkie filmy (≤32 s) są próbkowane z częstotliwością 1 klatki na sekundę, a dłuższe filmy są próbkowane równomiernie do 32 klatek. Ścieżki audio nie są przetwarzane w plikach wideo.
Dokumenty (PDF) Maksymalnie 1 plik na żądanie, do 6 stron.

Umieszczanie obrazów

Poniższy przykład pokazuje, jak umieścić obraz za pomocą gemini-embedding-2.

Obrazy można przesyłać jako dane wbudowane lub jako przesłane pliki za pomocą interfejsu Files API.

Python

from google import genai
from google.genai import types

with open('example.png', 'rb') as f:
    image_bytes = f.read()

client = genai.Client()

result = client.models.embed_content(
    model='gemini-embedding-2',
    contents=[
        types.Part.from_bytes(
            data=image_bytes,
            mime_type='image/png',
        ),
    ]
)

print(result.embeddings)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

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

    const imgBase64 = fs.readFileSync("example.png", { encoding: "base64" });

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-2',
        contents: [{
            inlineData: {
                mimeType: 'image/png',
                data: imgBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

Java

import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.EmbedContentResponse;
import com.google.genai.types.Part;
import java.nio.file.Files;
import java.nio.file.Paths;

Client client = new Client();

byte[] imageBytes = Files.readAllBytes(Paths.get("example.png"));

Content content = Content.fromParts(Part.fromBytes(imageBytes, "image/png"));

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", content, null);

System.out.println(response.embeddings().orElse(null));

REST

IMG_PATH="/path/to/your/image.png"
IMG_BASE64=$(base64 -w0 "${IMG_PATH}")

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2:embedContent" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: ${GEMINI_API_KEY}" \
    -d '{
        "content": {
            "parts": [{
                "inline_data": {
                    "mime_type": "image/png",
                    "data": "'"${IMG_BASE64}"'"
                }
            }]
        }
    }'

Agregacja wektorów dystrybucyjnych

Podczas pracy z treściami multimodalnymi sposób strukturyzowania danych wejściowych wpływa na dane wyjściowe wektora dystrybucyjnego:

  • Wiele części (zagregowane): dodanie wielu danych wejściowych bezpośrednio do parametru contents powoduje wygenerowanie jednego zagregowanego wektora dystrybucyjnego dla wszystkich danych wejściowych.
  • Wiele obiektów Content (osobno): opakowanie każdego obiektu wejściowego w obiekt Content i przekazanie ich w parametrze contents zwraca osobne wektory dystrybucyjne dla każdego wpisu.
  • Reprezentacja na poziomie posta: w przypadku złożonych obiektów, takich jak posty w mediach społecznościowych z wieloma elementami multimedialnymi, zalecamy agregowanie oddzielnych wektorów dystrybucyjnych (np. przez uśrednianie) w celu utworzenia spójnej reprezentacji na poziomie posta.

Poniższy przykład pokazuje, jak utworzyć jeden zagregowany wektor dystrybucyjny dla danych wejściowych w postaci tekstu i obrazu. Wystarczy dodać wiele danych wejściowych do parametru contents:

Python

from google import genai
from google.genai import types

client = genai.Client()

with open('dog.png', 'rb') as f:
    image_bytes = f.read()

result = client.models.embed_content(
    model='gemini-embedding-2',
    contents=[
        "An image of a dog",
        types.Part.from_bytes(
            data=image_bytes,
            mime_type='image/png',
        ),
    ]
)

# This produces one embedding
for embedding in result.embeddings:
    print(embedding.values)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

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

    const imgBase64 = fs.readFileSync("dog.png", { encoding: "base64" });

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-2',
        contents: [
            'An image of a dog',
            {
                inlineData: {
                    mimeType: 'image/png',
                    data: imgBase64,
                },
            },
        ],
    });

    // This produces one embedding
    for (const embedding of response.embeddings) {
        console.log(embedding.values);
    }
}

main();

Java

import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.ContentEmbedding;
import com.google.genai.types.EmbedContentResponse;
import com.google.genai.types.Part;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Collections;

Client client = new Client();

byte[] imageBytes = Files.readAllBytes(Paths.get("dog.png"));

Content content =
    Content.fromParts(
        Part.fromText("An image of a dog"),
        Part.fromBytes(imageBytes, "image/png"));

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", content, null);

// This produces one embedding
for (ContentEmbedding embedding : response.embeddings().orElse(Collections.emptyList())) {
  System.out.println(embedding.values().orElse(Collections.emptyList()));
}

REST

IMG_PATH="/path/to/your/dog.png"
IMG_BASE64=$(base64 -w0 "${IMG_PATH}")

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2:embedContent" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: ${GEMINI_API_KEY}" \
    -d '{
        "content": {
            "parts": [
                {"text": "An image of a dog"},
                {
                    "inline_data": {
                        "mime_type": "image/png",
                        "data": "'"${IMG_BASE64}"'"
                    }
                }
            ]
        }
    }'

Jeśli jednak użyjesz obiektów Content w parametrze contents, zwróci on osobne wektory dystrybucyjne. Ten przykład tworzy wiele wektorów dystrybucyjnych w jednym wywołaniu wektora dystrybucyjnego:

Python

from google import genai
from google.genai import types

client = genai.Client()

with open('dog.png', 'rb') as f:
    image_bytes = f.read()

result = client.models.embed_content(
    model="gemini-embedding-2",
    contents=[
        types.Content(parts=[types.Part.from_text(text="task: classification | query: An image of a dog")]),
        types.Content(
            parts=[
                types.Part.from_bytes(
                    data=image_bytes,
                    mime_type="image/png",
                ),
            ]
        ),
    ],
)

# This produces two embeddings
for embedding in result.embeddings:
    print(embedding.values)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

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

    const imgBase64 = fs.readFileSync("dog.png", { encoding: "base64" });

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-2',
        contents: [
            { parts: [{ text: 'task: classification | query: An image of a dog' }] },
            {
                parts: [{
                    inlineData: {
                        mimeType: 'image/png',
                        data: imgBase64,
                    },
                }],
            },
        ],
    });

    // This produces two embeddings
    for (const embedding of response.embeddings) {
        console.log(embedding.values);
    }
}

main();

Java

import java.util.Arrays;
import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.ContentEmbedding;
import com.google.genai.types.EmbedContentResponse;
import com.google.genai.types.Part;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Collections;
import java.util.List;

Client client = new Client();

byte[] imageBytes = Files.readAllBytes(Paths.get("dog.png"));

List<Content> contents =
    Arrays.asList(
        Content.fromParts(Part.fromText("task: classification | query: An image of a dog")),
        Content.fromParts(Part.fromBytes(imageBytes, "image/png")));

// Embed each Content object separately to produce separate embeddings
for (Content content : contents) {
  EmbedContentResponse response =
      client.models.embedContent("gemini-embedding-2", content, null);
  for (ContentEmbedding embedding : response.embeddings().orElse(Collections.emptyList())) {
    System.out.println(embedding.values().orElse(Collections.emptyList()));
  }
}

REST

IMG_PATH="/path/to/your/dog.png"
IMG_BASE64=$(base64 -w0 "${IMG_PATH}")

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2:batchEmbedContents" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: ${GEMINI_API_KEY}" \
    -d '{
        "requests": [
            {
                "model": "models/gemini-embedding-2",
                "content": {"parts": [{"text": "task: classification | query: An image of a dog"}]}
            },
            {
                "model": "models/gemini-embedding-2",
                "content": {"parts": [{"inline_data": {"mime_type": "image/png", "data": "'"${IMG_BASE64}"'"}}]}
            }
        ]
    }'

Osadzanie dźwięku

Poniższy przykład pokazuje, jak umieścić plik audio za pomocą elementu gemini-embedding-2.

Pliki audio można przesyłać jako dane wbudowane lub jako pliki przesłane za pomocą interfejsu Files API.

Python

from google import genai
from google.genai import types

with open('example.mp3', 'rb') as f:
    audio_bytes = f.read()

client = genai.Client()

result = client.models.embed_content(
    model='gemini-embedding-2',
    contents=[
        types.Part.from_bytes(
            data=audio_bytes,
            mime_type='audio/mpeg',
        ),
    ]
)

print(result.embeddings)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

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

    const audioBase64 = fs.readFileSync("example.mp3", { encoding: "base64" });

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-2',
        contents: [{
            inlineData: {
                mimeType: 'audio/mpeg',
                data: audioBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

Java

import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.EmbedContentResponse;
import com.google.genai.types.Part;
import java.nio.file.Files;
import java.nio.file.Paths;

Client client = new Client();

byte[] audioBytes = Files.readAllBytes(Paths.get("example.mp3"));

Content content = Content.fromParts(Part.fromBytes(audioBytes, "audio/mpeg"));

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", content, null);

System.out.println(response.embeddings().orElse(null));

REST

AUDIO_PATH="/path/to/your/example.mp3"
AUDIO_BASE64=$(base64 -w0 "${AUDIO_PATH}")

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2:embedContent" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: ${GEMINI_API_KEY}" \
    -d '{
        "content": {
            "parts": [{
                "inline_data": {
                    "mime_type": "audio/mpeg",
                    "data": "'"${AUDIO_BASE64}"'"
                }
            }]
        }
    }'

Umieszczanie filmu

Ten przykład pokazuje, jak umieścić film za pomocą gemini-embedding-2.

Filmy można przesyłać jako dane wbudowane lub jako przesłane pliki za pomocą interfejsu Files API.

Python

from google import genai
from google.genai import types

client = genai.Client()

with open('example.mp4', 'rb') as f:
    video_bytes = f.read()

result = client.models.embed_content(
    model='gemini-embedding-2',
    contents=[
        types.Part.from_bytes(
            data=video_bytes,
            mime_type='video/mp4',
        ),
    ]
)

print(result.embeddings[0].values)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

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

    const videoBase64 = fs.readFileSync("example.mp4", { encoding: "base64" });

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-2',
        contents: [{
            inlineData: {
                mimeType: 'video/mp4',
                data: videoBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

Java

import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.EmbedContentResponse;
import com.google.genai.types.Part;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Collections;

Client client = new Client();

byte[] videoBytes = Files.readAllBytes(Paths.get("example.mp4"));

Content content = Content.fromParts(Part.fromBytes(videoBytes, "video/mp4"));

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", content, null);

System.out.println(
    response.embeddings().get().get(0).values().orElse(Collections.emptyList()));

REST

VIDEO_PATH="/path/to/your/video.mp4"
VIDEO_BASE64=$(base64 -w0 "${VIDEO_PATH}")

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2:embedContent" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: ${GEMINI_API_KEY}" \
    -d '{
        "content": {
            "parts": [{
                "inline_data": {
                    "mime_type": "video/mp4",
                    "data": "'"${VIDEO_BASE64}"'"
                }
            }]
        }
    }'

Jeśli chcesz umieścić filmy dłuższe niż 120 sekund, możesz podzielić je na nakładające się segmenty i umieścić je osobno.

Dokumenty wektorów dystrybucyjnych

Dokumenty w formacie PDF można umieszczać bezpośrednio. Model przetwarza treści wizualne i tekstowe każdej strony.

Pliki PDF można przesyłać jako dane wbudowane lub jako przesłane pliki za pomocą interfejsu Files API.

Jak model przetwarza pliki PDF

Gdy umieszczasz plik PDF, model przetwarza dokument, korzystając zarówno z funkcji wizualnych, jak i tekstowych:

  • Reprezentacja wizualna: model renderuje każdą stronę jako obraz, co zużywa 258 tokenów na stronę.
  • Wyodrębnianie tekstu: model wyodrębnia tekst z dokumentu. W przypadku natywnych plików PDF (które zawierają tekst cyfrowy) model wyodrębnia tekst bezpośrednio. W przypadku zeskanowanych plików PDF (które zawierają obrazy tekstu) model automatycznie uruchamia optyczne rozpoznawanie znaków (OCR), aby wyodrębnić tekst.

Aby obliczyć łączną liczbę tokenów w pliku PDF, dodaj tokeny wizualne (258 na stronę) do tokenów tekstowych. Dane wejściowe muszą mieścić się w limicie 8192 tokenów modelu (wspólnym dla wszystkich modalności). System bez powiadomienia skraca dane wejściowe, które przekraczają ten limit.

Limity dotyczące plików PDF

  • Liczba plików na żądanie: możesz przesłać maksymalnie 1 plik PDF.
  • Limit stron: możesz przesłać maksymalnie 6 stron na plik. Aby uzyskać najlepszą jakość, zdecydowanie zalecamy używanie 1 strony na plik PDF.

Poniższy przykład pokazuje, jak umieścić plik PDF za pomocą gemini-embedding-2:

Python

from google import genai
from google.genai import types

with open('example.pdf', 'rb') as f:
    pdf_bytes = f.read()

client = genai.Client()

result = client.models.embed_content(
    model='gemini-embedding-2',
    contents=[
        types.Part.from_bytes(
            data=pdf_bytes,
            mime_type='application/pdf',
        ),
    ]
)

print(result.embeddings)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

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

    const pdfBase64 = fs.readFileSync("example.pdf", { encoding: "base64" });

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-2',
        contents: [{
            inlineData: {
                mimeType: 'application/pdf',
                data: pdfBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

Java

import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.EmbedContentResponse;
import com.google.genai.types.Part;
import java.nio.file.Files;
import java.nio.file.Paths;

Client client = new Client();

byte[] pdfBytes = Files.readAllBytes(Paths.get("example.pdf"));

Content content = Content.fromParts(Part.fromBytes(pdfBytes, "application/pdf"));

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", content, null);

System.out.println(response.embeddings().orElse(null));

REST

PDF_PATH="/path/to/your/example.pdf"
PDF_BASE64=$(base64 -w0 "${PDF_PATH}")

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2:embedContent" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: ${GEMINI_API_KEY}" \
    -d '{
        "content": {
            "parts": [{
                "inline_data": {
                    "mime_type": "application/pdf",
                    "data": "'"${PDF_BASE64}"'"
                }
            }]
        }
    }'

Przypadki użycia

Wektory dystrybucyjne tekstu są kluczowe w przypadku wielu typowych zastosowań AI, takich jak:

Przechowywanie wektorów dystrybucyjnych

Podczas 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 wymiarowości. Google Cloud oferuje zarządzane usługi danych, które można wykorzystać w tym celu, w tym Gemini Enterprise Agent Platform Wyszukiwanie wektorowe 2.0, BigQuery, AlloyDB i Cloud SQL.

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

Wersje modelu

Gemini Embedding 2

Właściwość Opis
Kod modelu

Gemini API

gemini-embedding-2
Obsługiwane typy danych

Wejście

Tekst, obraz, film, dźwięk, PDF

Dane wyjściowe

Wektory dystrybucyjne tekstu
Limity tokenów[*]

Limit tokenów wejściowych

8192

Rozmiar wymiaru wyjściowego

Elastyczny, obsługuje: 128–3072, zalecane: 768, 1536, 3072
Wersje
Więcej informacji znajdziesz we wzorcach wersji modelu .
  • Stabilny: gemini-embedding-2
Ostatnia aktualizacja Kwiecień 2026 r.

Gemini Embedding

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: 128–3072, zalecane: 768, 1536, 3072
Wersje
Więcej informacji znajdziesz we wzorcach wersji modelu .
  • Stabilny: gemini-embedding-001
Ostatnia aktualizacja Czerwiec 2025 r.

Informacje o wycofanych modelach wektorów dystrybucyjnych znajdziesz na stronie Wycofane funkcje.

Migracja z gemini-embedding-001

Przestrzenie wektorów dystrybucyjnych między gemini-embedding-001 a gemini-embedding-2 są niezgodne. Oznacza to, że nie można bezpośrednio porównywać wektorów dystrybucyjnych wygenerowanych przez jeden model z wektorami dystrybucyjnymi wygenerowanymi przez drugi. Jeśli przechodzisz na gemini-embedding-2, musisz ponownie umieścić wszystkie istniejące dane.

Oprócz niezgodności między tymi dwoma modelami występują też inne istotne różnice:

  • Określanie typu zadania: w gemini-embedding-001 typ zadania określasz za pomocą parametru task_type (np. SEMANTIC_SIMILARITY, RETRIEVAL_DOCUMENT). W gemini-embedding-2 parametr task_type nie jest obsługiwany. Zamiast tego w przypadku zadań tekstowych instrukcje należy umieszczać bezpośrednio w prompcie. Szczegółowe informacje o formatowaniu promptów w różnych przypadkach użycia znajdziesz w sekcji Typy zadań w Embeddings 2.

  • Agregacja wektorów dystrybucyjnych: gemini-embedding-001 generuje osobne wektory dystrybucyjne dla każdego ciągu znaków na liście danych wejściowych. Z kolei gemini-embedding-2 generuje pojedynczy, zagregowany wektor dystrybucyjny, gdy w jednym żądaniu podano bezpośrednio wiele danych wejściowych (takich jak tekst i obrazy). Aby wygenerować osobne wektory dystrybucyjne dla poszczególnych danych wejściowych, umieść każde dane wejściowe w obiekcie Content lub użyj interfejsu Batch API. Więcej informacji znajdziesz w sekcji Agregacja wektorów dystrybucyjnych.

  • Normalizacja: jeśli używasz output_dimensionality do żądania wektorów dystrybucyjnych o mniej niż 3072 wymiarach, gemini-embedding-2 automatycznie normalizuje te obcięte wektory dystrybucyjne. W przypadku gemini-embedding-001 musisz przeprowadzić ręczną normalizację wymiarów innych niż 3072. Więcej informacji znajdziesz w sekcji Zapewnianie jakości w przypadku mniejszych wymiarów.

Wektory dystrybucyjne zbiorcze

Jeśli czas oczekiwania nie jest problemem, spróbuj użyć modeli Gemini Embeddings z interfejsem Batch API. Umożliwia to znacznie większą przepustowość przy 50% domyślnej ceny wektora dystrybucyjnego. 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 wektorów dystrybucyjnych Gemini służy tylko do przekształcania formatu danych wejściowych w reprezentację liczbową. Google odpowiada za dostarczenie modelu wektorów dystrybucyjnych, który przekształca format danych wejściowych na wymagany format liczbowy, ale użytkownicy ponoszą pełną odpowiedzialność za wprowadzane dane i wynikające z nich wektory dystrybucyjne. Korzystając z modelu wektorów dystrybucyjnych Gemini, 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 wektorami dystrybucyjnymi

Zapoznaj się z notatnikiem z krótkim wprowadzeniem do wektorów dystrybucyjnych, aby poznać możliwości modelu i dowiedzieć się, jak dostosowywać i wizualizować wektory dystrybucyjne.