Texteinbettungen abrufen

Mit der Vertex AI Texteinbettungs-API können Sie eine Texteinbettung mithilfe von Generative AI in Vertex AI erstellen. Texteinbettungen sind numerische Darstellungen von Text, mit denen Beziehungen zwischen Wörtern und Wortgruppen erfasst werden. Modelle für maschinelles Lernen, insbesondere generative KI-Modelle, eignen sich zum Erstellen dieser Einbettungen, indem sie Muster in großen Text-Datasets identifizieren. Ihre Anwendung kann Texteinbettungen verwenden, um Sprache zu verarbeiten und zu erzeugen. Dadurch können komplexe Bedeutungen und semantische Beziehungen erkannt werden, die für Ihre Inhalte spezifisch sind. Sie interagieren jedes Mal mit Texteinbettungen, wenn Sie eine Google Suche durchführen oder Empfehlungen für Musikstreaming sehen.

Typische Anwendungsfälle für Texteinbettungen:

  • Semantische Suche: Suchtext, geordnet nach der semantischen Ähnlichkeit.
  • Klassifizierung: Gibt die Klasse von Elementen zurück, deren Textattribute dem angegebenen Text ähneln.
  • Clustering: Clusterelemente, deren Textattribute dem angegebenen Text ähneln.
  • Ausreißererkennung: Gibt Elemente zurück, bei denen Textattribute am wenigsten mit dem angegebenen Text zusammenhängen.
  • Unterhaltungsschnittstelle: Gruppiert Gruppen von Sätzen, die zu ähnlichen Antworten führen können, z. B. in einem Einbettungsbereich auf Unterhaltungsebene.

Bei Texteinbettungen wird Text in Arrays von Gleitkommazahlen umgewandelt, die als Vektoren bezeichnet werden. Diese Vektoren sind so konzipiert, dass sie die Bedeutung des Textes erfassen. Die Länge des Einbettungsarrays wird als Dimensionalität des Vektors bezeichnet. Beispielsweise könnte ein Textabschnitt durch einen Vektor mit Hunderten von Dimensionen dargestellt werden. Anschließend kann eine Anwendung durch Berechnung der numerischen Entfernung zwischen den Vektordarstellungen zweier Textelemente die Ähnlichkeit zwischen den Objekten ermitteln.

Die Vertex AI Text Embeddings API verwendet dichte Vektordarstellungen: text-embedding-gecko, beispielsweise 768-dimensionale Vektoren. Modelle mit dichten Vektoreinbettungen verwenden Deep-Learning-Methoden, die denen von Large Language Models ähneln. Im Gegensatz zu dünnbesetzten Vektoren, die Wörter direkt zu Zahlen zuordnen, sind dichte Vektoren so konzipiert, dass sie die Bedeutung eines Textes besser darstellen. Der Vorteil der dichten Vektoreinbettungen in der generativen KI besteht darin, dass Sie anstelle der direkten Übereinstimmungen mit Wörtern oder Syntaxen besser nach Passagen suchen können, die der Bedeutung der Abfrage entsprechen, selbst wenn die Abschnitte nicht dieselbe Sprache verwenden.

Vorbereitung

Für das Erstellen einer Einbettung gelten bestimmte Voraussetzungen. Informationen zum Einstieg finden Sie unter Kurzanleitung: Texteinbettungen ausprobieren.

Verwenden Sie dieses Colab, um die neu freigegebenen Texteinbettungsmodelle (textembedding-gecko und textembedding-gecko-multilingual) aufzurufen.

Jupyter-Notebook: Rufen Sie die Texteinbettungsmodelle mit Colab oder einem Jupyter-Notebook auf.
In Colab ausführen

Anwendungsbeispiel: Chatbot mit Buchempfehlung entwickeln

Wenn Sie einen Chatbot für eine Buchempfehlung entwickeln möchten, müssen Sie zuerst ein neuronales Deep-Learning-Netzwerk (DNN) verwenden, um jedes Buch in einen Einbettungsvektor umzuwandeln, wobei ein Einbettungsvektor ein Buch darstellt. Sie können als Eingabe für das DNN nur den Buchtitel oder nur den Textinhalt eingeben. Oder wir verwenden beide zusammen mit anderen Metadaten, die das Buch beschreiben, z. B. das Genre.

Die Einbettungen in diesem Beispiel könnten aus Tausenden von Buchtiteln mit Zusammenfassungen und ihrem Genre bestehen und möglicherweise Darstellungen für Bücher wie diese haben. Sturmhöhe von Emily Brontë und Anne Elliot von Jane Austen, die sich gegenseitig ähneln (kleine Entfernung zwischen numerischer Darstellung). Die numerische Darstellung für das Buch Der große Gatsby von F. Scott Fitzgerald wäre weniger nah, da Zeitraum, Genre und Zusammenfassung weniger ähnlich sind.

Die Eingaben stellen den wichtigsten Einfluss auf die Ausrichtung des Einbettungsbereichs dar. Wenn wir beispielsweise nur Eingaben für Buchtitel hatten, könnten zwei Bücher mit ähnlichen Titeln, aber sehr unterschiedlichen Zusammenfassungen nahe beieinander liegen. Wenn wir jedoch den Titel und die Zusammenfassung einschließen, sind diese Bücher im Einbettungsbereich weniger ähnlich (weiter weg).

Wenn dieser Chatbot mit Generative AI arbeitet, kann er anhand Ihrer Abfrage Bücher zusammenfassen, vorschlagen und Ihnen Bücher anzeigen, die Ihnen gefallen oder nicht gefallen könnten.

Unterstützte Modelle

Informationen zu den verfügbaren stabilen Versionen für Texteinbettungen finden Sie unter Verfügbare stabile Modellversionen. Informationen dazu, welche neuesten Versionen von Texteinbettungen verfügbar sind, finden Sie unter Neueste Modelle.

Es wird dringend empfohlen, eine stabile Modellversion (z. B.textembedding-gecko@003) anzugeben. Die neueste Modellversion befindet sich in der Vorschau und nicht allgemein verfügbar ist. Da sich die neueste Version in der Vorschau befindet, kann nicht sichergestellt werden, dass sie produktionsreif ist.

Es ist besonders wichtig, für Anwendungen, die rückwärtskompatible Einbettungen erfordern, eine stabile Modellversion (z. B. textembedding-gecko@003) zu verwenden. Wenn die Abwärtskompatibilität keine Rolle spielt und Sie die neueste Modellversion verwenden möchten, sollten Sie @latest explizit angeben. Wenn keine Version angegeben ist, wird textembedding-gecko standardmäßig auf textembedding-gecko@003 und textembedding-gecko-multilingual standardmäßig auf textembedding-gecko-multilingual@001 gesetzt.

Neueste Modelle

Für die Vorschau sind zwei Modelle verfügbar:

  • text-embedding-preview-0409
  • text-multilingual-embedding-preview-0409

Diese Modelle verbessern sich im Vergleich zu früheren Modellen in etablierten Benchmarks, die verschiedene nachgelagerte Aufgaben wie Abruf und Klassifizierung abdecken. Weitere Informationen finden Sie unter Gecko: Vielfältige Texteinbettungen, die aus Large Language Models destilliert werden.

Diese Modelle bieten eine bessere Einbettungsqualität als textembedding-gecko@003- bzw. textembedding-gecko-multilingual@001-Modelle. Diese Modelle unterscheiden sich von der Namenskonvention model-name@version. Geben Sie diese Modelle ohne das Suffix "@version" an. Hier ein Beispiel:

curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" -H "Content-Type: application/json" https://us-central1-aiplatform.googleapis.com/v1/projects/$PROJECT/locations/us-central1/publishers/google/models/text-embedding-preview-0409:predict -d $'{
  "instances": [
    { "content": "What is life?"}
  ],
}'

Neben der verbesserten Qualität unterstützen die neuen Modelle folgende Funktionen:

  • Ein neuer Parameter outputDimensionality wird unterstützt. Mit diesem Parameter können Sie die Einbettungsgröße reduzieren, z. B. zur Speicheroptimierung.

    • QUESTION_ANSWERING
    • FACT_VERIFICATION

    Es werden zwei neue Aufgabentypen unterstützt. Weitere Aufgabentypen finden Sie in der Modellreferenz.

Das folgende Beispiel zeigt die neuen Funktionen:

curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" -H "Content-Type: application/json" https://us-central1-aiplatform.googleapis.com/v1/projects/$PROJECT/locations/us-central1/publishers/google/models/text-embedding-preview-0409:predict -d $'{
  "instances": [
    {
      "task_type": "QUESTION_ANSWERING",
      "content": "What is life?"
    }
  ],
"parameters": {
    "outputDimensionality": 256
  }
}'

Bei der Verwendung dieser Modelle gelten die folgenden Beschränkungen:

  • Verwenden Sie diese Vorschaumodelle nicht für geschäftskritische oder Produktionssysteme.
  • Diese Modelle sind nur in us-central1 verfügbar.
  • Batchvorhersagen werden nicht unterstützt.
  • Anpassung wird nicht unterstützt.

Texteinbettungen für ein Text-Snippet abrufen

Sie können Texteinbettungen für ein Snippet aus Text mithilfe der Vertex AI API oder dem Vertex AI SDK für Python abrufen. Für jede Anfrage sind Sie auf fünf Eingabetexte beschränkt. Jeder Eingabetext hat ein Tokenlimit von 3.072. Eingaben, die länger als diese Länge sind, werden automatisch abgeschnitten. Sie können die automatische Kürzung auch deaktivieren, indem Sie autoTruncate auf false setzen.

In diesen Beispielen wird das textembedding-gecko@003-Modell verwendet.

REST

Senden Sie zum Abrufen von Texteinbettungen eine POST-Anfrage, wozu Sie die Modell-ID des Publisher-Modells angeben.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT_ID: Ihre Projekt-ID.
  • TEXT: Der Text, für den Sie Einbettungen generieren möchten. Limit: fünf Texte mit bis zu 3.072 Tokens pro Text.
  • AUTO_TRUNCATE: Wenn dieser Wert auf false gesetzt ist, schlägt der Text, der das Tokenlimit überschreitet, fehl. Der Standardwert ist true.

HTTP-Methode und URL:

POST https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/textembedding-gecko@003:predict

JSON-Text der Anfrage:

{
  "instances": [
    { "content": "TEXT"}
  ],
  "parameters": {
    "autoTruncate": AUTO_TRUNCATE
  }
}

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

curl

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

curl -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8" \
    -d @request.json \
    "https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/textembedding-gecko@003:predict"

PowerShell

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/textembedding-gecko@003:predict" | Select-Object -Expand Content

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten: Beachten Sie, dass values gekürzt wurde, um Speicherplatz zu sparen.

Beispiel: cURL-Befehls

MODEL_ID="textembedding-gecko@003"
PROJECT_ID=PROJECT_ID

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/${MODEL_ID}:predict -d \
$'{
  "instances": [
    { "content": "What is life?"}
  ],
}'

Python

Informationen zum Installieren oder Aktualisieren von Python finden Sie unter Vertex AI SDK für Python installieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Python API. 

from typing import List

from vertexai.language_models import TextEmbeddingInput, TextEmbeddingModel

def embed_text(
    texts: List[str] = ["banana muffins? ", "banana bread? banana muffins?"],
    task: str = "RETRIEVAL_DOCUMENT",
    model_name: str = "textembedding-gecko@003"
) -> List[List[float]]:
    """Embeds texts with a pre-trained, foundational model."""
    model = TextEmbeddingModel.from_pretrained(model_name)
    inputs = [TextEmbeddingInput(text, task) for text in texts]
    embeddings = model.get_embeddings(inputs)
    return [embedding.values for embedding in embeddings]

Go

Bevor Sie dieses Beispiel anwenden, folgen Sie den Go-Einrichtungsschritten in der Vertex AI-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI Go API.

Richten Sie zur Authentifizierung bei Vertex AI Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

import (
	"context"
	"fmt"
	"io"

	aiplatform "cloud.google.com/go/aiplatform/apiv1beta1"
	"cloud.google.com/go/aiplatform/apiv1beta1/aiplatformpb"
	"google.golang.org/api/option"
	"google.golang.org/protobuf/types/known/structpb"
)

// generateEmbeddings creates embeddings from text provided.
func generateEmbeddings(w io.Writer, prompt, project, location, publisher, model string) error {
	ctx := context.Background()

	apiEndpoint := fmt.Sprintf("%s-aiplatform.googleapis.com:443", location)

	client, err := aiplatform.NewPredictionClient(ctx, option.WithEndpoint(apiEndpoint))
	if err != nil {
		fmt.Fprintf(w, "unable to create prediction client: %v", err)
		return err
	}
	defer client.Close()

	// PredictRequest requires an endpoint, instances, and parameters
	// Endpoint
	base := fmt.Sprintf("projects/%s/locations/%s/publishers/%s/models", project, location, publisher)
	url := fmt.Sprintf("%s/%s", base, model)

	// Instances: the prompt
	promptValue, err := structpb.NewValue(map[string]interface{}{
		"content": prompt,
	})
	if err != nil {
		fmt.Fprintf(w, "unable to convert prompt to Value: %v", err)
		return err
	}

	// PredictRequest: create the model prediction request
	req := &aiplatformpb.PredictRequest{
		Endpoint:  url,
		Instances: []*structpb.Value{promptValue},
	}

	// PredictResponse: receive the response from the model
	resp, err := client.Predict(ctx, req)
	if err != nil {
		fmt.Fprintf(w, "error in prediction: %v", err)
		return err
	}

	fmt.Fprintf(w, "embeddings generated: %v", resp.Predictions[0])
	return nil
}

Java

Bevor Sie dieses Beispiel anwenden, folgen Sie den Java-Einrichtungsschritten in der Vertex AI-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI Java API.

Richten Sie zur Authentifizierung bei Vertex AI Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 


import com.google.cloud.aiplatform.util.ValueConverter;
import com.google.cloud.aiplatform.v1beta1.EndpointName;
import com.google.cloud.aiplatform.v1beta1.PredictResponse;
import com.google.cloud.aiplatform.v1beta1.PredictionServiceClient;
import com.google.cloud.aiplatform.v1beta1.PredictionServiceSettings;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class PredictTextEmbeddingsSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // Details about text embedding request structure and supported models are available in:
    // https://cloud.google.com/vertex-ai/docs/generative-ai/embeddings/get-text-embeddings
    String instance = "{ \"content\": \"What is life?\"}";
    String project = "YOUR_PROJECT_ID";
    String location = "us-central1";
    String publisher = "google";
    String model = "textembedding-gecko@001";

    predictTextEmbeddings(instance, project, location, publisher, model);
  }

  // Get text embeddings from a supported embedding model
  public static void predictTextEmbeddings(
      String instance, String project, String location, String publisher, String model)
      throws IOException {
    String endpoint = String.format("%s-aiplatform.googleapis.com:443", location);
    PredictionServiceSettings predictionServiceSettings =
        PredictionServiceSettings.newBuilder()
            .setEndpoint(endpoint)
            .build();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (PredictionServiceClient predictionServiceClient =
        PredictionServiceClient.create(predictionServiceSettings)) {
      EndpointName endpointName =
          EndpointName.ofProjectLocationPublisherModelName(project, location, publisher, model);

      // Use Value.Builder to convert instance to a dynamically typed value that can be
      // processed by the service.
      Value.Builder instanceValue = Value.newBuilder();
      JsonFormat.parser().merge(instance, instanceValue);
      List<Value> instances = new ArrayList<>();
      instances.add(instanceValue.build());

      PredictResponse predictResponse =
          predictionServiceClient.predict(endpointName, instances, ValueConverter.EMPTY_VALUE);
      System.out.println("Predict Response");
      for (Value prediction : predictResponse.getPredictionsList()) {
        System.out.format("\tPrediction: %s\n", prediction);
      }
    }
  }
}

Node.js

Bevor Sie dieses Beispiel anwenden, folgen Sie den Node.js-Einrichtungsschritten in der Vertex AI-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI Node.js API.

Richten Sie zur Authentifizierung bei Vertex AI Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';
const aiplatform = require('@google-cloud/aiplatform');

// Imports the Google Cloud Prediction service client
const {PredictionServiceClient} = aiplatform.v1;

// Import the helper module for converting arbitrary protobuf.Value objects.
const {helpers} = aiplatform;

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

const publisher = 'google';
const model = 'textembedding-gecko@001';

// Instantiates a client
const predictionServiceClient = new PredictionServiceClient(clientOptions);

async function callPredict() {
  // Configure the parent resource
  const endpoint = `projects/${project}/locations/${location}/publishers/${publisher}/models/${model}`;

  const instance = {
    content: 'What is life?',
  };
  const instanceValue = helpers.toValue(instance);
  const instances = [instanceValue];

  const parameter = {
    temperature: 0,
    maxOutputTokens: 256,
    topP: 0,
    topK: 1,
  };
  const parameters = helpers.toValue(parameter);

  const request = {
    endpoint,
    instances,
    parameters,
  };

  // Predict request
  const [response] = await predictionServiceClient.predict(request);
  console.log('Get text embeddings response');
  const predictions = response.predictions;
  console.log('\tPredictions :');
  for (const prediction of predictions) {
    console.log(`\t\tPrediction : ${JSON.stringify(prediction)}`);
  }
}

callPredict();

Einbettung zu einer Vektordatenbank hinzufügen

Nachdem Sie die Einbettung erstellt haben, können Sie einer Vektordatenbank wie der Vektorsuche Einbettungen hinzufügen. Dies ermöglicht einen Abruf mit niedriger Latenz und ist von entscheidender Bedeutung, wenn die Größe Ihrer Daten zunimmt.

Weitere Informationen zur Vektorsuche finden Sie unter Übersicht über die Vektorsuche.

API-Änderungen an Modellen, die im oder nach August 2023 veröffentlicht wurden

Bei Verwendung von Modellversionen, die am oder nach August 2023 veröffentlicht wurden, einschließlich textembedding-gecko@003 und textembedding-gecko-multilingual@001, gibt es einen neuen Aufgabentypparameter und den optionalen Titel (nur mit task_type=RETRIEVAL_DOCUMENT gültig).

Diese neuen Parameter gelten für diese öffentlichen Vorschaumodelle und alle stabilen Modelle.

{
  "instances": [
    {
      "task_type": "RETRIEVAL_DOCUMENT",
      "title": "document title",
      "content": "I would like embeddings for this text!"
    },
  ]
}

Der Parameter task_type wird als beabsichtigte nachgelagerte Anwendung definiert, um dem Modell zu helfen, Einbettungen mit höherer Qualität zu erstellen. Dies ist ein String, der einen der folgenden Werte annehmen kann:

task_type Beschreibung
RETRIEVAL_QUERY Gibt an, dass der angegebene Text eine Abfrage in einer Such- oder Abrufeinstellung ist.
RETRIEVAL_DOCUMENT Gibt an, dass der angegebene Text ein Dokument in einer Such- oder Abrufeinstellung ist.
SEMANTIC_SIMILARITY Gibt an, dass der angegebene Text für die semantische Textähnlichkeit (Semantic Textual Similarity, STS) verwendet wird.
CLASSIFICATION Gibt an, dass die Einbettung zur Klassifizierung verwendet wird.
CLUSTERING Gibt an, dass die Einbettung für das Clustering verwendet wird.
QUESTION_ANSWERING Gibt an, dass die Abfrageeinbettung zur Beantwortung von Fragen verwendet wird. Verwenden Sie RETRIEVAL_DOCUMENT für die Dokumentseite.
FACT_VERIFICATION Gibt an, dass die Abfrageeinbettung für die Faktenüberprüfung verwendet wird.

Sprachabdeckung für textembedding-gecko-multilingual-Modelle.

Das textembedding-gecko-multilingual@001-Modell wurde für die folgenden Sprachen ausgewertet: Arabic (ar), Bengali (bn), English (en), Spanish (es), German (de), Persian (fa), Finnish (fi), French (fr), Hindi (hi), Indonesian (id), Japanese (ja), Korean (ko), Russian (ru), Swahili (sw), Telugu (te) ,Thai (th), Yoruba (yo), Chinese (zh).

Im Folgenden finden Sie eine vollständige Liste der unterstützten Sprachen: Afrikaans, Albanian, Amharic, Arabic, Armenian, Azerbaijani, Basque, Belarusian, Bengali, Bulgarian, Burmese, Catalan, Cebuano, Chichewa, Chinese, Corsican, Czech, Danish, Dutch, English, Esperanto, Estonian, Filipino, Finnish, French, Galician, Georgian, German, Greek, Gujarati, Haitian Creole, Hausa, Hawaiian, Hebrew, Hindi, Hmong, Hungarian, Icelandic, Igbo, Indonesian, Irish, Italian, Japanese, Javanese, Kannada, Kazakh, Khmer, Korean, Kurdish, Kyrgyz, Lao, Latin, Latvian, Lithuanian, Luxembourgish, Macedonian, Malagasy, Malay, Malayalam, Maltese, Maori, Marathi, Mongolian, Nepali, Norwegian, Pashto, Persian, Polish, Portuguese, Punjabi, Romanian, Russian, Samoan, Scottish Gaelic, Serbian, Shona, Sindhi, Sinhala, Slovak, Slovenian, Somali, Sotho, Spanish, Sundanese, Swahili, Swedish, Tajik, Tamil, Telugu, Thai, Turkish, Ukrainian, Urdu, Uzbek, Vietnamese, Welsh, West Frisian, Xhosa, Yiddish, Yoruba, Zulu eine

Nächste Schritte