Embeddings

L'API Gemini propose des modèles d'embedding de texte pour générer des embeddings pour les mots, les expressions, les phrases et le code. Ces embeddings fondamentaux permettent d'effectuer des tâches de traitement du langage naturel (NLP) avancées telles que la recherche sémantique, la classification et le clustering. Ils fournissent des résultats plus précis et tenant compte du contexte que les approches basées sur les mots clés.

La création de systèmes de génération augmentée par récupération (RAG) est un cas d'utilisation courant pour les embeddings. Les embeddings jouent un rôle clé dans l'amélioration significative des résultats des modèles en termes de précision factuelle, de cohérence et de richesse contextuelle. Ils récupèrent efficacement les informations pertinentes des bases de connaissances, représentées par des embeddings, qui sont ensuite transmises en tant que contexte supplémentaire dans la requête d'entrée aux modèles de langage, ce qui les guide pour générer des réponses plus informées et plus précises.

Pour les applications de niveau entreprise et les charges de travail à volume élevé, nous vous suggérons d'utiliser des modèles d'embedding sur Vertex AI.

Génération d'embeddings

Utilisez la méthode embedContent pour générer des embeddings textuels :

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

Vous pouvez également générer des embeddings pour plusieurs blocs à la fois en les transmettant sous forme de liste de chaînes.

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

Spécifiez le type de tâche pour améliorer les performances

Vous pouvez utiliser des embeddings pour un large éventail de tâches, de la classification à la recherche de documents. Spécifier le bon type de tâche permet d'optimiser les embeddings pour les relations souhaitées, ce qui maximise la précision et l'efficacité. Pour obtenir la liste complète des types de tâches acceptés, consultez le tableau Types de tâches acceptés.

L'exemple suivant montre comment utiliser SEMANTIC_SIMILARITY pour vérifier la similarité sémantique de chaînes de texte.

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

Voici un exemple de résultat de cet extrait de code :

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

Types de tâches compatibles

Type de tâche Description Exemples
SEMANTIC_SIMILARITY Embeddings optimisés pour évaluer la similarité de texte. Systèmes de recommandation, détection des doublons
CLASSIFICATION Embeddings optimisés pour classer des textes en fonction d'étiquettes prédéfinies. Analyse des sentiments, détection du spam
CLUSTERING Embeddings optimisés pour regrouper des textes en fonction de leurs similitudes. Organisation de documents, études de marché, détection d'anomalies
RETRIEVAL_DOCUMENT Embeddings optimisés pour la recherche de documents. Indexation d'articles, de livres ou de pages Web pour la recherche.
RETRIEVAL_QUERY Embeddings optimisés pour les requêtes de recherche générales. Utilisez RETRIEVAL_QUERY pour les requêtes et RETRIEVAL_DOCUMENT pour les documents à récupérer. Tests personnalisés sur le Réseau de Recherche
CODE_RETRIEVAL_QUERY Embeddings optimisés pour la récupération de blocs de code en fonction de requêtes en langage naturel. Utilisez CODE_RETRIEVAL_QUERY pour les requêtes et RETRIEVAL_DOCUMENT pour les blocs de code à récupérer. Suggestions de code et recherche
QUESTION_ANSWERING Embeddings pour les questions dans un système de questions-réponses, optimisés pour trouver les documents qui répondent à la question. Utilisez QUESTION_ANSWERING pour les questions et RETRIEVAL_DOCUMENT pour les documents à récupérer. Chatbox
FACT_VERIFICATION Embeddings pour les déclarations à valider, optimisés pour récupérer les documents contenant des preuves qui soutiennent ou réfutent la déclaration. Utilisez FACT_VERIFICATION pour le texte cible et RETRIEVAL_DOCUMENT pour les documents à récupérer. Systèmes de fact-checking automatisés

Contrôler la taille de l'intégration

Le modèle d'embedding Gemini, gemini-embedding-001, est entraîné à l'aide de la technique d'apprentissage de la représentation Matryoshka (MRL, Matryoshka Representation Learning). Cette technique permet à un modèle d'apprendre des embeddings de grande dimension dont les segments initiaux (ou préfixes) sont également des versions plus simples et utiles des mêmes données. Vous pouvez choisir d'utiliser l'intégralité de l'embedding à 3 072 dimensions ou le tronquer à une taille plus petite sans perte de qualité pour économiser de l'espace de stockage. Pour une qualité optimale, nous vous recommandons d'utiliser les deux premières résolutions (768 et 1 536).

En utilisant le paramètre output_dimensionality, les utilisateurs peuvent contrôler la taille du vecteur d'intégration de sortie. En sélectionnant une dimensionnalité de sortie plus petite, vous pouvez économiser de l'espace de stockage et augmenter l'efficacité de calcul pour les applications en aval, tout en sacrifiant peu de qualité.

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

Exemple de résultat :

Length of embedding: 768

L'embedding de dimension 3072 est normalisé. Les embeddings normalisés produisent une similarité sémantique plus précise en comparant la direction du vecteur, et non son amplitude. Pour les autres dimensions, y compris 768 et 1 536, vous devez normaliser les embeddings comme suit :

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

Exemple de résultat :

Normed embedding length: 768
Norm of normed embedding: 1.000000

Cas d'utilisation

Les embeddings de texte sont essentiels pour de nombreux cas d'utilisation courants de l'IA, tels que :

  • Génération augmentée par récupération (RAG) : les embeddings améliorent la qualité du texte généré en récupérant et en intégrant des informations pertinentes dans le contexte d'un modèle.

  • Récupération d'informations : utilisez des embeddings pour rechercher du texte ou des documents sémantiquement similaires à partir d'un texte d'entrée.

    Tutoriel sur la recherche de documents

  • Détection des anomalies : la comparaison de groupes d'embeddings peut aider à identifier des tendances ou des valeurs aberrantes cachées.

    Tutoriel sur la détection d'anomalies

  • Classification : catégorisez automatiquement le texte en fonction de son contenu, comme l'analyse des sentiments ou la détection du spam.

    Tutoriel sur la classification

  • Clustering : un moyen efficace de comprendre les relations consiste à créer des clusters et des visualisations de vos embeddings.

    Tutoriel sur la visualisation du clustering

Stocker les embeddings

Lorsque vous mettez des embeddings en production, il est courant d'utiliser des bases de données vectorielles pour stocker, indexer et récupérer efficacement des embeddings de grande dimension. Google Cloud propose des services de données gérés qui peuvent être utilisés à cette fin, y compris BigQuery, AlloyDB et Cloud SQL.

Les tutoriels suivants montrent comment utiliser d'autres bases de données vectorielles tierces avec Gemini Embedding.

Modèles d'embedding

Modèle en disponibilité générale

Anciens modèles

  • embedding-001 (sera abandonné le 14 août 2025)
  • text-embedding-004 (sera abandonné le 14 janvier 2026)

Utiliser des embeddings

Contrairement aux modèles d'IA générative qui créent de nouveaux contenus, le modèle Gemini Embedding est uniquement destiné à transformer le format de vos données d'entrée en représentation numérique. Bien que Google soit responsable de la fourniture d'un modèle d'embedding qui transforme le format de vos données d'entrée au format numérique demandé, les utilisateurs conservent l'entière responsabilité des données qu'ils saisissent et des embeddings qui en résultent. En utilisant le modèle Gemini Embedding, vous confirmez que vous disposez des droits nécessaires sur tous les contenus que vous mettez en ligne. Ne générez aucun contenu qui porte atteinte à la propriété intellectuelle ou aux droits au respect de la confidentialité d'autrui. L'utilisation de ce service est soumise à notre Règlement sur les utilisations interdites et aux Conditions d'utilisation de Google.

Commencer à créer avec des embeddings

Consultez le notebook de démarrage rapide sur les embeddings pour explorer les capacités du modèle et découvrir comment personnaliser et visualiser vos embeddings.