Ottieni incorporamenti di testo

Puoi creare un incorporamento di testo utilizzando l'API Text Embeddings di Vertex AI. Gli incorporamenti di testo sono rappresentazioni numeriche del testo che acquisiscono le relazioni tra parole e frasi. I modelli di machine learning, in particolare quelli di AI generativa, sono adatti per creare questi incorporamenti identificando pattern all'interno di set di dati di testo di grandi dimensioni. La tua applicazione può utilizzare gli incorporamenti di testo per elaborare e produrre il linguaggio e riconoscere significati complessi e relazioni semantiche specifiche per i tuoi contenuti. interagisci con gli incorporamenti di testo ogni volta che completi una Ricerca Google o vedi consigli per lo streaming di musica.

Alcuni casi d'uso comuni per gli incorporamenti di testo includono:

• Ricerca semantica: testo di ricerca classificato per somiglianza semantica.
• Classificazione: restituisce la classe degli elementi 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: restituisce gli elementi in cui gli attributi di testo sono meno correlati al testo specificato.
• Interfaccia conversazionale: raggruppa gruppi di frasi che possono portare a risposte simili, ad esempio in uno spazio di incorporamento a livello di conversazione.

Gli incorporamenti di testo funzionano convertendo il testo in array di numeri in virgola mobile, chiamati vettori. Questi vettori sono progettati per acquisire 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 a 768 dimensioni. I modelli di incorporamento vettoriale denso utilizzano metodi di deep learning simili a quelli utilizzati dai modelli linguistici di grandi dimensioni. A differenza dei vettori sparsi, che tendono a mappare direttamente le parole ai numeri, i vettori densi sono progettati per rappresentare meglio il significato di una porzione di testo. Il vantaggio dell'utilizzo di rappresentazioni distribuite di vettori densi nell&#39AIA generativa è che, invece di cercare corrispondenze di parole dirette o sintassi, puoi cercare meglio i passaggi in linea con il significato della query, anche se i passaggi non usano la stessa lingua.

• Per scoprire di più sugli incorporamenti, consulta Il multistrumento di Meet AI: incorporamenti vettoriali.
• Per seguire un corso sugli arresti anomali di ML di base sugli incorporamenti, consulta Incorporamenti.
• Per saperne di più su come archiviare gli incorporamenti vettoriali in un database, consulta la pagina Scopri e la Panoramica della ricerca vettoriale
• Per saperne di più sui modelli di incorporamento del testo, consulta Incorporamenti del testo.

Per un esempio di come ottenere incorporamenti di testo, esegui il blocco note Jupyter "Text Embedding New API" in uno dei seguenti ambienti:

Apri in Colab | Apri in Colab Enterprise | Apri nei blocchi note gestiti dall'utente di Vertex AI Workbench | Visualizza su GitHub

Prima di iniziare

1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Attiva l'API Vertex AI.

   Abilita l'API

4. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

5. Attiva l'API Vertex AI.

   Abilita l'API

Ottieni gli incorporamenti di testo per uno snippet di testo

Puoi ottenere gli incorporamenti di testo per uno snippet di testo utilizzando l'API Vertex AI o l'SDK Vertex AI per Python. Per ogni richiesta, esiste un limite di 250 testi di input in us-central1 e in altre regioni il numero massimo di testi di input è 5. Ogni testo di input ha un limite di token di 2048. 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 text-embedding-004.

REST

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

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

• PROJECT_ID: il tuo ID progetto.
• TEXT: il testo per cui vuoi generare gli incorporamenti. Limite: cinque testi fino a un massimo di 2048 token per testo.
• AUTO_TRUNCATE: se impostato su false, un testo che supera il limite di token determina la mancata riuscita 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/text-embedding-004:predict

Corpo JSON della richiesta:

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

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

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 fa accedere automaticamente all'interfaccia a riga di comando di 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/text-embedding-004:predict"

PowerShell

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando di 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/text-embedding-004:predict" | Select-Object -Expand Content

Dovresti ricevere una risposta 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="text-embedding-004"
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, vedi Installare l'SDK Vertex AI per Python. Per maggiori informazioni, 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 = "RETRIEVAL_DOCUMENT",
    model_name: str = "text-embedding-004",
    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 per la configurazione di Go nella guida rapida di Vertex AI sull'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Go Vertex AI.

Per eseguire l'autenticazione su Vertex AI, configura 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, customOutputDimensionality *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 customOutputDimensionality != nil {
		outputDimensionality = structpb.NewNumberValue(float64(*customOutputDimensionality))
	}
	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 per la configurazione di Java nella guida rapida di Vertex AI sull'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Java Vertex AI.

Per eseguire l'autenticazione su Vertex AI, configura 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.OptionalInt;
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 = "text-embedding-004";
    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 per la configurazione di Node.js nella guida rapida di Vertex AI sull'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Node.js Vertex AI.

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

async function main(
  project,
  model = 'text-embedding-004',
  texts = 'banana bread?;banana muffins?',
  task = 'QUESTION_ANSWERING',
  outputDimensionality = 0,
  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 location = 'us-central1';
  const endpoint = `projects/${project}/locations/${location}/publishers/google/models/${model}`;
  const parameters =
    outputDimensionality > 0
      ? helpers.toValue(outputDimensionality)
      : helpers.toValue(256);

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

Aggiungi un incorporamento a un database vettoriale

Dopo aver generato l'incorporamento, puoi aggiungerlo a un database vettoriale, come Vector Search. Ciò consente il recupero a bassa latenza ed è fondamentale man mano che le dimensioni dei dati aumentano.

Per ulteriori informazioni sulla ricerca vettoriale, consulta la Panoramica della ricerca vettoriale.

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

Se vuoi sviluppare un chatbot per i suggerimenti di libri, la prima cosa da fare è utilizzare una rete neurale profonda (DNN) per convertire ogni libro in un vettore di incorporamento, dove un vettore di incorporamento rappresenta un libro. Puoi fornire come input alla DNN solo il titolo del libro o solo il contenuto del testo. Oppure puoi usarli entrambi 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 riassunti e il relativo genere e potrebbero avere rappresentazioni per libri come Wuthering Heights di Emily Brontë e Persuasion di Jane Austen che sono simili tra loro (a poca distanza tra la rappresentazione numerica). mentre la rappresentazione numerica del libro Il grande Gatsby di F. Scott Fitzgerald andrebbe più avanti, perché periodo di tempo, genere e riassunto sono meno simili.

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

Grazie all'utilizzo dell'AI generativa, questo chatbot per suggerimenti di libri potrebbe riassumere, suggerire e mostrarti libri che potrebbero piacerti (o non ti piacciono) in base alla tua query.

Modifiche alle API per i modelli rilasciati ad agosto 2023 o in una data successiva

Quando utilizzi le versioni del modello rilasciate a partire da agosto 2023, tra cui text-embedding-004 e textembedding-gecko-multilingual@001, è disponibile un nuovo parametro per il tipo di attività e il titolo facoltativo (valido solo con task_type=RETRIEVAL_DOCUMENT).

Questi nuovi parametri si applicano ai modelli di anteprima pubblica e a tutti i modelli stabili in futuro.

{
  "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 la somiglianza testuale semantica (STS).
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 del documento.
FACT_VERIFICATION	Specifica che l'incorporamento delle query viene utilizzato per la verifica dei fatti.

Passaggi successivi

• Per ottenere previsioni batch per gli incorporamenti, consulta Ottenere previsioni batch per gli incorporamenti di testo
• Per saperne di più sugli incorporamenti multimodali, consulta Ottenere incorporamenti multimodali
• Per ottimizzare un incorporamento, consulta Ottimizzare gli incorporamenti di testo.