Ricevi incorporamenti di testo

L'API Vertex AI text-embeddings ti consente di creare un incorporamento di testo utilizzando l'IA generativa su Vertex AI. Le rappresentazioni distribuite di testo sono rappresentazioni numeriche di testo che catturano le relazioni tra parole e frasi. I modelli di machine learning, in particolare i modelli di AI generativa, sono adatti per creare questi incorporamenti identificando pattern all'interno di grandi set di dati di testo. La tua applicazione può utilizzare gli incorporamenti di testo per elaborare e produrre il linguaggio, riconoscendo significati complessi e relazioni semantiche specifiche per i tuoi contenuti. interagisci con gli incorporamenti di testo ogni volta che completi una ricerca su Google o visualizzi consigli per lo streaming di musica.

Ecco alcuni casi d'uso comuni per gli incorporamenti di testo:

• Ricerca semantica: testo di ricerca classificato in base alla somiglianza semantica.
• Classificazione: restituisce la classe di articoli i cui attributi di testo sono simili al testo specificato.
• Cluster: elementi del cluster i cui attributi di testo sono simili al testo specificato.
• Rilevamento outlier: restituisci articoli in cui gli attributi di testo sono meno correlati al testo specificato.
• Interfaccia di conversazione: raggruppa gruppi di frasi che possono generare risposte simili, ad esempio in uno spazio di incorporamento a livello di conversazione.

Gli incorporamenti di testo convertono il testo in array di numeri in virgola mobile, chiamati vettori. Questi vettori sono progettati per catturare il significato del testo. La lunghezza dell'array di incorporamento è chiamata dimensionalità del vettore. Ad esempio, un passaggio di testo potrebbe essere rappresentato da un vettore contenente centinaia di dimensioni. Quindi, calcolando la distanza numerica tra le rappresentazioni vettoriali di due parti di testo, un'applicazione può determinare la somiglianza tra gli oggetti.

L'API Vertex AI text Embeddings utilizza rappresentazioni vettoriali dense: text-embedding-gecko, ad esempio, utilizza vettori di 768 dimensioni. I modelli di incorporazione vettoriale densa usano metodi di deep learning simili a quelli usati dai modelli linguistici di grandi dimensioni. A differenza dei vettori sparsi, che tendono ad associare direttamente le parole ai numeri, i vettori dense sono progettati per rappresentare meglio il significato di una porzione di testo. Il vantaggio dell'utilizzo di incorporamenti vettoriali densi nell'AI generativa è che, invece di cercare corrispondenze dirette di parole o sintassi, puoi cercare meglio i passaggi che si allineano al significato della query, anche se i passaggi non utilizzano la stessa lingua.

• Per scoprire di più sugli incorporamenti, consulta Il multistrumento di Meet AI: rappresentazioni distribuite vettoriali.
• Per seguire un corso sugli arresti anomali di base per il machine learning sugli incorporamenti, consulta Incorporamenti.
• Per scoprire di più su come archiviare incorporamenti vettoriali in un database, consulta la pagina Scopri e la pagina Panoramica di Vector Search

Prerequisiti

Esistono prerequisiti specifici per creare correttamente un incorporamento. Per iniziare, consulta la guida rapida: Provare gli incorporamenti di testo.

Utilizza questo Colab per chiamare i modelli di incorporamento del testo appena rilasciati (textembedding-gecko e textembedding-gecko-multilingual). Blocco note Jupyter: chiama i modelli di incorporamento del testo utilizzando Colab o un blocco note Jupyter. Esegui in Colab

Esempio di caso d'uso: sviluppare un chatbot per suggerimenti di libri

Se vuoi sviluppare un chatbot per suggerimenti di libri, la prima cosa da fare è utilizzare una rete neurale profonda (DNN) per convertire ogni libro in un vettore di incorporamento, in cui un vettore di incorporamento rappresenta un libro. Puoi inserire, come input nel DNN, solo il titolo del libro o solo il contenuto testuale. In alternativa, puoi utilizzarli insieme, insieme ad altri metadati che descrivono il libro, come il genere.

Gli incorporamenti in questo esempio potrebbero essere costituiti da migliaia di titoli di libri con riepiloghi e relativo genere e potrebbero avere rappresentazioni per libri come Wuthering Heights di Emily Brontë e Persuasion di Jane Austen simili tra loro (piccola distanza tra le rappresentazioni numeriche). Mentre la rappresentazione numerica per il libro Il grande Gatsby di F. Scott Fitzgerald andrebbe oltre, poiché il periodo di tempo, il genere e il riassunto sono meno simili.

Gli input sono la principale influenza sull'orientamento dello spazio di incorporamento. Ad esempio, se avessimo inserito solo il titolo dei libri, due libri con titoli simili, ma con riassunti molto diversi, potrebbero essere vicini. Tuttavia, se includiamo il titolo e il riepilogo, questi stessi libri sono meno simili (più lontano) nello spazio di incorporamento.

Grazie all'AI generativa, questo chatbot di suggerimenti di libri può riassumere, suggerire e mostrarti libri che potrebbero piacerti (o non ti piace) in base alla tua query.

Modelli supportati

Per sapere quali versioni del modello di incorporamento del testo stabile sono disponibili, consulta Versioni del modello stabile disponibili. Per scoprire quali ultime versioni dei modelli di incorporamento del testo sono disponibili, consulta Modelli più recenti.

Ti consigliamo vivamente di specificare una versione del modello stabile (ad esempio, textembedding-gecko@003). La versione più recente di un modello è in modalità Anteprima e non è in disponibilità generale (GA). Poiché la versione più recente è in Anteprima, non è garantito che sia pronta per la produzione.

È particolarmente importante utilizzare una versione stabile del modello, ad esempio textembedding-gecko@003 per le applicazioni che richiedono incorporamenti compatibili con le versioni precedenti. Se la compatibilità con le versioni precedenti non è un problema e vuoi utilizzare la versione più recente del modello, devi specificare @latest esplicitamente. Se non viene specificata alcuna versione, il valore predefinito di textembedding-gecko è textembedding-gecko@003 e textembedding-gecko-multilingual il valore predefinito è textembedding-gecko-multilingual@001.

Modelli più recenti

Anteprima

Questo prodotto o funzionalità è soggetto ai "Termini delle Offerte pre-GA" nella sezione Termini generali del servizio dei Termini specifici del servizio. I prodotti e le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per saperne di più, consulta le descrizioni della fase di lancio.

Per l'anteprima sono disponibili due modelli:

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

Questi modelli migliorano rispetto ai modelli precedenti all'interno di benchmark consolidati che coprono varie attività a valle, come il recupero e la classificazione. Per saperne di più, consulta Gecko: incorporamenti di testo versatili distillati da modelli linguistici di grandi dimensioni (LLM).

Questi modelli offrono una qualità di incorporamento migliore, rispettivamente, rispetto ai modelli textembedding-gecko@003 e textembedding-gecko-multilingual@001. Questi modelli non rispettano la convenzione di denominazione model-name@version. Specifica questi modelli senza il suffisso "@version". Ecco un esempio:

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

Oltre a una migliore qualità, i nuovi modelli supportano le seguenti funzionalità:

• È supportato un nuovo parametro outputDimensionality. Puoi utilizzare questo parametro per ridurre le dimensioni di incorporamento, ad esempio per l'ottimizzazione dello spazio di archiviazione.

  • QUESTION_ANSWERING
  • FACT_VERIFICATION

  Sono supportati due nuovi tipi di attività. Per vedere altri tipi di attività, consulta il riferimento del modello.

L'esempio seguente illustra le nuove funzionalità:

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

Quando utilizzi questi modelli, si applicano le seguenti limitazioni:

• Non utilizzare questi modelli in anteprima su sistemi mission critical o di produzione.
• Questi modelli sono disponibili solo in us-central1.
• Le previsioni batch non sono supportate.
• La personalizzazione non è supportata.

Ricevi incorporamenti di testo per uno snippet di testo

Puoi ottenere incorporamenti di testo per uno snippet di testo utilizzando l'API Vertex AI o l'SDK Vertex AI per Python. Per ogni richiesta, è previsto un limite di 250 testi di input in us-central1 e in altre regioni, il testo di input massimo è 5. Ogni testo di input ha un limite di token di 2000. Gli input più lunghi di questa lunghezza vengono troncati silenziosamente. Puoi anche disattivare il troncamento silenzioso impostando autoTruncate su false.

Questi esempi utilizzano il modello textembedding-gecko@003.

REST

Per ottenere incorporamenti di testo, invia una richiesta POST specificando l'ID modello del modello editore.

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

• PROJECT_ID: il tuo ID progetto.
• TEXT: il testo per cui vuoi generare incorporamenti. Limite: cinque testi con un massimo di 3072 token per testo.
• AUTO_TRUNCATE: se viene impostato su false, un testo che supera il limite di token determina l'esito negativo della richiesta. Il valore predefinito è true.

Metodo HTTP e URL:

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

Corpo JSON della richiesta:

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

Per inviare la richiesta, scegli una delle seguenti opzioni:

arricciatura

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti consente di accedere automaticamente all'interfaccia a riga di comando gcloud. Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

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

Nota: il seguente comando presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

$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

Dovresti ricevere una risposta in formato JSON simile alla seguente. Tieni presente che values è stato troncato per risparmiare spazio.

Risposta

{
  "predictions": [
    {
      "embeddings": {
        "statistics": {
          "truncated": false,
          "token_count": 6
        },
        "values": [ ... ]
      }
    }
  ]
}

Comando curl di esempio

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

Per scoprire come installare o aggiornare l'SDK Vertex AI per Python, consulta Installare l'SDK Vertex AI per Python. Per saperne di più, consulta la documentazione di riferimento dell'API Python.

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Go riportate nella guida rapida di Vertex AI sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Go Vertex AI.

Per eseguire l'autenticazione in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

import (
	"context"
	"fmt"
	"regexp"

	aiplatform "cloud.google.com/go/aiplatform/apiv1"
	"cloud.google.com/go/aiplatform/apiv1/aiplatformpb"

	"google.golang.org/api/option"
	"google.golang.org/protobuf/types/known/structpb"
)

func embedTexts(
	apiEndpoint, project, model string, texts []string, task string) ([][]float32, error) {
	ctx := context.Background()

	client, err := aiplatform.NewPredictionClient(ctx, option.WithEndpoint(apiEndpoint))
	if err != nil {
		return nil, err
	}
	defer client.Close()

	match := regexp.MustCompile(`^(\w+-\w+)`).FindStringSubmatch(apiEndpoint)
	location := "us-central1"
	if match != nil {
		location = match[1]
	}
	endpoint := fmt.Sprintf("projects/%s/locations/%s/publishers/google/models/%s", project, location, model)
	instances := make([]*structpb.Value, len(texts))
	for i, text := range texts {
		instances[i] = structpb.NewStructValue(&structpb.Struct{
			Fields: map[string]*structpb.Value{
				"content":   structpb.NewStringValue(text),
				"task_type": structpb.NewStringValue(task),
			},
		})
	}

	req := &aiplatformpb.PredictRequest{
		Endpoint:  endpoint,
		Instances: instances,
	}
	resp, err := client.Predict(ctx, req)
	if err != nil {
		return nil, err
	}
	embeddings := make([][]float32, len(resp.Predictions))
	for i, prediction := range resp.Predictions {
		values := prediction.GetStructValue().Fields["embeddings"].GetStructValue().Fields["values"].GetListValue().Values
		embeddings[i] = make([]float32, len(values))
		for j, value := range values {
			embeddings[i][j] = float32(value.GetNumberValue())
		}
	}
	return embeddings, nil
}

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java riportate nella guida rapida di Vertex AI sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java Vertex AI.

Per eseguire l'autenticazione in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

import static java.util.stream.Collectors.toList;

import com.google.cloud.aiplatform.v1.EndpointName;
import com.google.cloud.aiplatform.v1.PredictRequest;
import com.google.cloud.aiplatform.v1.PredictResponse;
import com.google.cloud.aiplatform.v1.PredictionServiceClient;
import com.google.cloud.aiplatform.v1.PredictionServiceSettings;
import com.google.protobuf.Struct;
import com.google.protobuf.Value;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

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 endpoint = "us-central1-aiplatform.googleapis.com:443";
    String project = "YOUR_PROJECT_ID";
    String model = "textembedding-gecko@003";
    predictTextEmbeddings(
        endpoint,
        project,
        model,
        List.of("banana bread?", "banana muffins?"),
        "RETRIEVAL_DOCUMENT");
  }

  // Gets text embeddings from a pretrained, foundational model.
  public static List<List<Float>> predictTextEmbeddings(
      String endpoint, String project, String model, List<String> texts, String task)
      throws IOException {
    PredictionServiceSettings settings =
        PredictionServiceSettings.newBuilder().setEndpoint(endpoint).build();
    Matcher matcher = Pattern.compile("^(?<Location>\\w+-\\w+)").matcher(endpoint);
    String location = matcher.matches() ? matcher.group("Location") : "us-central1";
    EndpointName endpointName =
        EndpointName.ofProjectLocationPublisherModelName(project, location, "google", model);

    // You can use this prediction service client for multiple requests.
    try (PredictionServiceClient client = PredictionServiceClient.create(settings)) {
      PredictRequest.Builder request =
          PredictRequest.newBuilder().setEndpoint(endpointName.toString());
      for (int i = 0; i < texts.size(); i++) {
        request.addInstances(
            Value.newBuilder()
                .setStructValue(
                    Struct.newBuilder()
                        .putFields("content", valueOf(texts.get(i)))
                        .putFields("taskType", valueOf(task))
                        .build()));
      }
      PredictResponse response = client.predict(request.build());
      List<List<Float>> floats = new ArrayList<>();
      for (Value prediction : response.getPredictionsList()) {
        Value embeddings = prediction.getStructValue().getFieldsOrThrow("embeddings");
        Value values = embeddings.getStructValue().getFieldsOrThrow("values");
        floats.add(
            values.getListValue().getValuesList().stream()
                .map(Value::getNumberValue)
                .map(Double::floatValue)
                .collect(toList()));
      }
      return floats;
    }
  }

  private static Value valueOf(String s) {
    return Value.newBuilder().setStringValue(s).build();
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js riportate nella guida rapida di Vertex AI sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Node.js Vertex AI.

Per eseguire l'autenticazione in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

async function main(
  project,
  model = 'textembedding-gecko@003',
  texts = 'banana bread?;banana muffins?',
  task = 'RETRIEVAL_DOCUMENT',
  apiEndpoint = 'us-central1-aiplatform.googleapis.com'
) {
  const aiplatform = require('@google-cloud/aiplatform');
  const {PredictionServiceClient} = aiplatform.v1;
  const {helpers} = aiplatform; // helps construct protobuf.Value objects.
  const clientOptions = {apiEndpoint: apiEndpoint};
  const match = apiEndpoint.match(/(?<Location>\w+-\w+)/);
  const location = match ? match.groups.Location : 'us-centra11';
  const endpoint = `projects/${project}/locations/${location}/publishers/google/models/${model}`;

  async function callPredict() {
    const instances = texts
      .split(';')
      .map(e => helpers.toValue({content: e, taskType: task}));
    const request = {endpoint, instances};
    const client = new PredictionServiceClient(clientOptions);
    const [response] = await client.predict(request);
    console.log('Got predict response');
    const predictions = response.predictions;
    for (const prediction of predictions) {
      const embeddings = prediction.structValue.fields.embeddings;
      const values = embeddings.structValue.fields.values.listValue.values;
      console.log('Got prediction: ' + JSON.stringify(values));
    }
  }

  callPredict();
}

Ricevi incorporamenti di testo per uno snippet di testo (modelli di anteprima)

Questa sezione fornisce esempi per i nuovi modelli di incorporamenti:

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

Python

Per scoprire come installare o aggiornare l'SDK Vertex AI per Python, consulta Installare l'SDK Vertex AI per Python. Per saperne di più, consulta la documentazione di riferimento dell'API Python.

from typing import List, Optional

from vertexai.language_models import TextEmbeddingInput, TextEmbeddingModel


def embed_text(
    texts: List[str] = ["banana muffins? ", "banana bread? banana muffins?"],
    task: str = "QUESTION_ANSWERING",
    model_name: str = "text-embedding-preview-0409",
    dimensionality: Optional[int] = 256,
) -> 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]
    kwargs = dict(output_dimensionality=dimensionality) if dimensionality else {}
    embeddings = model.get_embeddings(inputs, **kwargs)
    return [embedding.values for embedding in embeddings]

Go

Prima di provare questo esempio, segui le istruzioni di configurazione di Go riportate nella guida rapida di Vertex AI sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Go Vertex AI.

Per eseguire l'autenticazione in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

import (
	"context"
	"fmt"
	"regexp"

	aiplatform "cloud.google.com/go/aiplatform/apiv1"
	"cloud.google.com/go/aiplatform/apiv1/aiplatformpb"

	"google.golang.org/api/option"
	"google.golang.org/protobuf/types/known/structpb"
)

func embedTextsPreview(
	apiEndpoint, project, model string, texts []string,
	task string, dimensionality *int) ([][]float32, error) {
	ctx := context.Background()

	client, err := aiplatform.NewPredictionClient(ctx, option.WithEndpoint(apiEndpoint))
	if err != nil {
		return nil, err
	}
	defer client.Close()

	match := regexp.MustCompile(`^(\w+-\w+)`).FindStringSubmatch(apiEndpoint)
	location := "us-central1"
	if match != nil {
		location = match[1]
	}
	endpoint := fmt.Sprintf("projects/%s/locations/%s/publishers/google/models/%s", project, location, model)
	instances := make([]*structpb.Value, len(texts))
	for i, text := range texts {
		instances[i] = structpb.NewStructValue(&structpb.Struct{
			Fields: map[string]*structpb.Value{
				"content":   structpb.NewStringValue(text),
				"task_type": structpb.NewStringValue(task),
			},
		})
	}
	outputDimensionality := structpb.NewNullValue()
	if dimensionality != nil {
		outputDimensionality = structpb.NewNumberValue(float64(*dimensionality))
	}
	params := structpb.NewStructValue(&structpb.Struct{
		Fields: map[string]*structpb.Value{"outputDimensionality": outputDimensionality},
	})

	req := &aiplatformpb.PredictRequest{
		Endpoint:   endpoint,
		Instances:  instances,
		Parameters: params,
	}
	resp, err := client.Predict(ctx, req)
	if err != nil {
		return nil, err
	}
	embeddings := make([][]float32, len(resp.Predictions))
	for i, prediction := range resp.Predictions {
		values := prediction.GetStructValue().Fields["embeddings"].GetStructValue().Fields["values"].GetListValue().Values
		embeddings[i] = make([]float32, len(values))
		for j, value := range values {
			embeddings[i][j] = float32(value.GetNumberValue())
		}
	}
	return embeddings, nil
}

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java riportate nella guida rapida di Vertex AI sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java Vertex AI.

Per eseguire l'autenticazione in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

import static java.util.stream.Collectors.toList;

import com.google.cloud.aiplatform.v1beta1.EndpointName;
import com.google.cloud.aiplatform.v1beta1.PredictRequest;
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.Struct;
import com.google.protobuf.Value;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.OptionalInt;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class PredictTextEmbeddingsSamplePreview {
  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 endpoint = "us-central1-aiplatform.googleapis.com";
    String project = "YOUR_PROJECT_ID";
    String model = "text-embedding-preview-0409";
    predictTextEmbeddings(
        endpoint,
        project,
        model,
        List.of("banana bread?", "banana muffins?"),
        "QUESTION_ANSWERING",
        OptionalInt.of(256));
  }

  // Gets text embeddings from a pretrained, foundational model.
  public static List<List<Float>> predictTextEmbeddings(
      String endpoint,
      String project,
      String model,
      List<String> texts,
      String task,
      OptionalInt outputDimensionality)
      throws IOException {
    PredictionServiceSettings settings =
        PredictionServiceSettings.newBuilder().setEndpoint(endpoint).build();
    Matcher matcher = Pattern.compile("^(?<Location>\\w+-\\w+)").matcher(endpoint);
    String location = matcher.matches() ? matcher.group("Location") : "us-central1";
    EndpointName endpointName =
        EndpointName.ofProjectLocationPublisherModelName(project, location, "google", model);

    // You can use this prediction service client for multiple requests.
    try (PredictionServiceClient client = PredictionServiceClient.create(settings)) {
      PredictRequest.Builder request =
          PredictRequest.newBuilder().setEndpoint(endpointName.toString());
      if (outputDimensionality.isPresent()) {
        request.setParameters(
            Value.newBuilder()
                .setStructValue(
                    Struct.newBuilder()
                        .putFields("outputDimensionality", valueOf(outputDimensionality.getAsInt()))
                        .build()));
      }
      for (int i = 0; i < texts.size(); i++) {
        request.addInstances(
            Value.newBuilder()
                .setStructValue(
                    Struct.newBuilder()
                        .putFields("content", valueOf(texts.get(i)))
                        .putFields("taskType", valueOf(task))
                        .build()));
      }
      PredictResponse response = client.predict(request.build());
      List<List<Float>> floats = new ArrayList<>();
      for (Value prediction : response.getPredictionsList()) {
        Value embeddings = prediction.getStructValue().getFieldsOrThrow("embeddings");
        Value values = embeddings.getStructValue().getFieldsOrThrow("values");
        floats.add(
            values.getListValue().getValuesList().stream()
                .map(Value::getNumberValue)
                .map(Double::floatValue)
                .collect(toList()));
      }
      return floats;
    }
  }

  private static Value valueOf(String s) {
    return Value.newBuilder().setStringValue(s).build();
  }

  private static Value valueOf(int n) {
    return Value.newBuilder().setNumberValue(n).build();
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js riportate nella guida rapida di Vertex AI sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Node.js Vertex AI.

Per eseguire l'autenticazione in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

async function main(
  project,
  model = 'text-embedding-preview-0409',
  texts = 'banana bread?;banana muffins?',
  task = 'QUESTION_ANSWERING',
  outputDimensionality = 256,
  apiEndpoint = 'us-central1-aiplatform.googleapis.com'
) {
  const aiplatform = require('@google-cloud/aiplatform');
  const {PredictionServiceClient} = aiplatform.v1;
  const {helpers} = aiplatform; // helps construct protobuf.Value objects.
  const clientOptions = {apiEndpoint: apiEndpoint};
  const match = apiEndpoint.match(/(?<Location>\w+-\w+)/);
  const location = match ? match.groups.Location : 'us-centra11';
  const endpoint = `projects/${project}/locations/${location}/publishers/google/models/${model}`;
  const parameters = helpers.toValue(outputDimensionality);

  async function callPredict() {
    const instances = texts
      .split(';')
      .map(e => helpers.toValue({content: e, taskType: task}));
    const request = {endpoint, instances, parameters};
    const client = new PredictionServiceClient(clientOptions);
    const [response] = await client.predict(request);
    console.log('Got predict response');
    const predictions = response.predictions;
    for (const prediction of predictions) {
      const embeddings = prediction.structValue.fields.embeddings;
      const values = embeddings.structValue.fields.values.listValue.values;
      console.log('Got prediction: ' + JSON.stringify(values));
    }
  }

  callPredict();
}

Aggiungere un incorporamento a un database vettoriale

Dopo aver generato l'incorporamento, puoi aggiungere incorporamenti a un database vettoriale, come Vector Search. Ciò consente il recupero a bassa latenza, fondamentale con l'aumento delle dimensioni dei dati.

Per scoprire di più su Vector Search, consulta la pagina Panoramica di Vector Search.

Modifiche all'API per i modelli rilasciati a partire da agosto 2023

Quando utilizzi le versioni del modello rilasciate a partire da agosto 2023, inclusi textembedding-gecko@003 e textembedding-gecko-multilingual@001, sono disponibili un nuovo parametro del tipo di attività e il titolo facoltativo (valido solo con task_type=RETRIEVAL_DOCUMENT).

Questi nuovi parametri vengono applicati ai modelli di anteprima pubblica e a tutti i modelli stabili futuri.

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

Il parametro task_type è definito come l'applicazione downstream prevista per aiutare il modello a produrre incorporamenti di qualità migliore. È una stringa che può assumere uno dei seguenti valori:

task_type	Descrizione
RETRIEVAL_QUERY	Specifica che il testo specificato è una query in un'impostazione di ricerca o recupero.
RETRIEVAL_DOCUMENT	Specifica che il testo specificato è un documento in un'impostazione di ricerca o recupero.
SEMANTIC_SIMILARITY	Specifica che il testo specificato viene utilizzato per STS (Semantic Textual Similarity).
CLASSIFICATION	Specifica che l'incorporamento viene utilizzato per la classificazione.
CLUSTERING	Specifica che l'incorporamento viene utilizzato per il clustering.
QUESTION_ANSWERING	Specifica che l'incorporamento delle query viene utilizzato per rispondere alle domande. Utilizza RETRIEVAL_DOCUMENT per il lato documento.
FACT_VERIFICATION	Specifica che l'incorporamento della query viene utilizzato per la verifica dei fatti.

Copertura linguistica per textembedding-gecko-multilingual modelli.

Il modello textembedding-gecko-multilingual@001 è stato valutato nelle seguenti lingue: 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) e Chinese (zh).

{6, {6, {6,} {4, {4, {6,} {4, {6, {4,}, {4, {7, {6,} {f/m, {m, {f/m}, {f/m}, {7, {6, {f/m}/m/}, {4, Belarusian/ {6, Belarusian/ {4, {m/m/}/ {7, Basque/ {6, Belarusian/ {6, Belarusian/ {7, Amharic/ {2, {m/}/ {7, Basque/ Amharic)AfrikaansAlbanianArabicArmenianAzerbaijaniBengaliBulgarianBurmeseCatalanCebuanoChichewaChineseCorsicanCzechDanishDutchEnglishEsperantoEstonianFilipinoFinnishFrenchGalicianGeorgianGermanGreekGujaratiHaitian CreoleHausaHawaiianHebrewHindiHmongHungarianIcelandicIgboIndonesianIrishItalianJapaneseJavaneseKannadaKazakhKhmerKoreanKurdishKyrgyzLaoLatinLatvianLithuanianLuxembourgishMacedonianMalagasyMalayMalayalamMalteseMaoriMarathiMongolianNepaliNorwegianPashtoPersianPolishPortuguesePunjabiRomanianRussianSamoanScottish GaelicSerbianShonaSindhiSinhalaSlovakSlovenianSomaliSothoSpanishSundaneseSwahiliSwedishTajikTamilTeluguThaiTurkishUkrainianUrduUzbekVietnameseWelshWest FrisianXhosaYiddishYorubaZulu

Passaggi successivi

• Scopri come ottimizzare un modello di base.
• Scopri le best practice per l'IA responsabile e i filtri di sicurezza di Vertex AI.