Embeddings

Gemini API ofron modele të futjes së tekstit për të gjeneruar ngulitje për fjalë, fraza, fjali dhe kode. Këto përfshirje themelore fuqizojnë detyra të avancuara të NLP-së si kërkimi semantik, klasifikimi dhe grupimi, duke ofruar rezultate më të sakta, të vetëdijshme për kontekstin sesa qasjet e bazuara në fjalë kyçe.

Building Retrieval Augmented Generation (RAG) sisteme është një rast i zakonshëm i përdorimit për ngulitje. Përfshirjet luajnë një rol kyç në rritjen e konsiderueshme të rezultateve të modelit me saktësi faktike të përmirësuar, koherencë dhe pasurim kontekstual. Ata marrin në mënyrë efikase informacionin përkatës nga bazat e njohurive, të përfaqësuara nga ngulitje, të cilat më pas kalohen si kontekst shtesë në kërkesën hyrëse për modelet gjuhësore, duke e udhëhequr atë për të gjeneruar përgjigje më të informuara dhe të sakta.

Për aplikacionet e nivelit të ndërmarrjeve dhe ngarkesat e punës me volum të lartë, ne sugjerojmë përdorimin e modeleve të ngulitjes në Vertex AI .

Gjenerimi i embeddings

Përdorni metodën embedContent për të gjeneruar ngulitje teksti:

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

Shkoni 

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

PUSHIMI 

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

Ju gjithashtu mund të gjeneroni ngulitje për disa pjesë në të njëjtën kohë duke i kaluar ato si një listë vargjesh.

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

Shkoni 

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

PUSHIMI 

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

Specifikoni llojin e detyrës për të përmirësuar performancën

Ju mund të përdorni ngulitje për një gamë të gjerë detyrash nga klasifikimi deri te kërkimi i dokumenteve. Specifikimi i llojit të duhur të detyrës ndihmon në optimizimin e përfshirjeve për marrëdhëniet e synuara, duke maksimizuar saktësinë dhe efikasitetin. Për një listë të plotë të llojeve të detyrave të mbështetura, shihni tabelën Llojet e detyrave të mbështetura .

Shembulli i mëposhtëm tregon se si mund të përdorni SEMANTIC_SIMILARITY për të kontrolluar se sa të ngjashëm në kuptim janë vargjet e teksteve.

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

Shkoni 

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

PUSHIMI 

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

Më poshtë tregon një shembull të daljes nga kjo copë kodi: 

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

Llojet e detyrave të mbështetura

Lloji i detyrës Përshkrimi Shembuj
SEMANTIC_SIMILARITY Embeddings optimizuar për të vlerësuar ngjashmërinë e tekstit. Sistemet e rekomandimit, zbulimi i dublikatave
KLASIFIKIMI Përfshirje të optimizuara për të klasifikuar tekstet sipas etiketave të paracaktuara. Analiza e ndjenjave, zbulimi i spamit
GRUPIM Embeddings optimizuar për të grupuar tekstet bazuar në ngjashmëritë e tyre. Organizimi i dokumenteve, hulumtimi i tregut, zbulimi i anomalive
RETRIEVAL_DOCUMENT Embeddings optimizuar për kërkimin e dokumenteve. Indeksimi i artikujve, librave ose faqeve të internetit për kërkim.
RETRIEVAL_QUERY Embeddings optimizuar për pyetje të përgjithshme kërkimi. Përdor RETRIEVAL_QUERY për pyetje; RETRIEVAL_DOCUMENT për dokumentet që do të merren. Kërkim i personalizuar
CODE_RETRIEVAL_QUERY Embeddings optimizuar për rikthimin e blloqeve të kodit bazuar në pyetjet e gjuhës natyrore. Përdorni CODE_RETRIEVAL_QUERY për pyetje; RETRIEVAL_DOCUMENT për blloqet e kodeve që do të merren. Sugjerime kodi dhe kërkim
PYETJE_PERGJIGJE Embeddings për pyetje në një sistem pyetje-përgjigje, i optimizuar për gjetjen e dokumenteve që i përgjigjen pyetjes. Përdor QUESTION_ANSWERING për pyetje; RETRIEVAL_DOCUMENT për dokumentet që do të merren. Chatbox
FACT_VERIFICATION Përfshirje për deklarata që duhet të verifikohen, të optimizuara për marrjen e dokumenteve që përmbajnë prova që mbështesin ose hedhin poshtë deklaratën. Përdorni FACT_VERIFICATION për tekstin e synuar; RETRIEVAL_DOCUMENT për dokumentet që do të merren Sisteme të automatizuara të kontrollit të fakteve

Kontrollimi i madhësisë së ngulitjes

Modeli i futjes së Gemini, gemini-embedding-001 , është trajnuar duke përdorur teknikën Matryoshka Representation Learning (MRL) e cila i mëson një modeli të mësojë ngulitje me dimensione të larta që kanë segmente (ose parashtesa) fillestare të cilat janë gjithashtu versione të dobishme, më të thjeshta të të njëjtave të dhëna. Mund të zgjidhni të përdorni futjen e plotë 3072-dimensionale ose mund ta shkurtoni në një madhësi më të vogël pa humbur cilësinë për të kursyer hapësirën e ruajtjes. Për cilësinë më të mirë, ne rekomandojmë përdorimin e 768 dhe 1536 të parë.

Duke përdorur parametrin output_dimensionality , përdoruesit mund të kontrollojnë madhësinë e vektorit të futjes së daljes. Zgjedhja e një dimensionaliteti më të vogël të daljes mund të kursejë hapësirën e ruajtjes dhe të rrisë efikasitetin llogaritës për aplikacionet e rrjedhës së poshtme, ndërkohë që sakrifikon pak për sa i përket cilësisë.

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

Shkoni 

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

PUSHIMI 

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

Shembull i daljes: 

Length of embedding: 768

Përfshirja e dimensionit 3072 është normalizuar. Përfshirjet e normalizuara prodhojnë ngjashmëri më të saktë semantike duke krahasuar drejtimin e vektorit, jo madhësinë. Për dimensionet e tjera, duke përfshirë 768 dhe 1536, duhet të normalizoni ngulitje si më poshtë:

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

Shembull i daljes: 

Normed embedding length: 768
Norm of normed embedding: 1.000000

Rastet e përdorimit

Përfshirja e tekstit është thelbësore për një sërë rastesh të zakonshme të përdorimit të AI, të tilla si:

  • Gjenerimi i shtuar nga rikthimi (RAG): Embeddings përmirësojnë cilësinë e tekstit të krijuar duke marrë dhe përfshirë informacionin përkatës në kontekstin e një modeli.

  • Rikthimi i informacionit: Përdorni ngulitje për të kërkuar tekst ose dokumente semantikisht të ngjashëm me një pjesë të tekstit hyrës.

    mësimore për kërkimin e dokumenteve

  • Zbulimi i anomalive: Krahasimi i grupeve të ngulitjes mund të ndihmojë në identifikimin e tendencave të fshehura ose të jashtme.

    udhëzues për zbulimin e anomalive

  • Klasifikimi: Kategorizo automatikisht tekstin bazuar në përmbajtjen e tij, të tilla si analiza e ndjenjave ose zbulimi i postës së padëshiruar

    tutorialit të klasifikimit

  • Grumbullimi: Një mënyrë efektive për të kuptuar marrëdhëniet është krijimi i grupimeve dhe vizualizimeve të përfshirjeve tuaja.

    udhëzues për vizualizimin e grupimeve

Ruajtja e embeddings

Ndërsa i çoni futjet në prodhim, është e zakonshme të përdorni bazat e të dhënave vektoriale për të ruajtur, indeksuar dhe rifituar me efikasitet ngulitje me dimensione të larta. Google Cloud ofron shërbime të menaxhuara të të dhënave që mund të përdoren për këtë qëllim, duke përfshirë BigQuery , AlloyDB dhe Cloud SQL .

Udhëzimet e mëposhtme tregojnë se si të përdorni bazat e të dhënave të tjera vektoriale të palëve të treta me Gemini Embedding.

Modelet e ngulitjes

Modeli i disponueshëm në përgjithësi

Modele të trashëgimisë

  • embedding-001 (Përdorimi më 14 gusht 2025)
  • text-embedding-004 (Duke hequr dorë më 14 janar 2026)

Duke përdorur embeddings

Ndryshe nga modelet gjeneruese të AI që krijojnë përmbajtje të re, modeli Gemini Embedding synon vetëm të transformojë formatin e të dhënave tuaja hyrëse në një paraqitje numerike. Ndërsa Google është përgjegjës për ofrimin e një modeli të integruar që transformon formatin e të dhënave tuaja hyrëse në formatin numerik të kërkuar, përdoruesit mbajnë përgjegjësi të plotë për të dhënat që futin dhe futjet që rezultojnë. Duke përdorur modelin Gemini Embedding ju konfirmoni se keni të drejtat e nevojshme për çdo përmbajtje që ngarkoni. Mos krijoni përmbajtje që cenon pronësinë intelektuale ose të drejtat e privatësisë së të tjerëve. Përdorimi juaj i këtij shërbimi është subjekt i Politikës sonë të Përdorimit të Ndaluar dhe Kushteve të Shërbimit të Google .

Filloni ndërtimin me ngulitje

Shikoni fletoren e nisjes së shpejtë të futjeve për të eksploruar aftësitë e modelit dhe për të mësuar se si të personalizoni dhe vizualizoni futjet tuaja.