Embeddings de texto

Embeddings de texto (textembedding-gecko) são o nome do modelo que suporta embeddings de texto. Os embeddings de texto são uma técnica de PLN que converte dados textuais em vetores numéricos que podem ser processados por algoritmos de aprendizado de máquina, especialmente modelos grandes. Essas representações vetoriais são projetadas para capturar o significado semântico e o contexto das palavras que representam.

Há algumas versões disponíveis para embeddings. textembedding-gecko@003 é o modelo de embedding estável mais recente com qualidade de IA aprimorada, e textembedding-gecko-multilingual@001 é um modelo otimizado para vários idiomas diferentes do inglês.

Para conferir esse modelo no console, consulte o Embeddings para card de modelo de texto no Model Garden.
Acessar o Model Garden

Casos de uso

Pesquisa semântica: embeddings de texto podem ser usados para representar a consulta do usuário e o universo de documentos em um espaço vetorial de alta dimensão. Os documentos que são semanticamente semelhantes à consulta do usuário terão uma distância menor no espaço vetorial e poderão ter uma classificação mais alta nos resultados da pesquisa.

Classificação de texto: como treinar um modelo que mapeia os embeddings de texto para os rótulos de categoria corretos (por exemplo, gato versus cachorro, spam versus não spam). Depois que o modelo é treinado, ele pode ser usado para classificar novas entradas de texto em uma ou mais categorias com base nos embeddings delas.

Solicitação HTTP

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

Versões do modelo

Para usar a versão mais recente do modelo, especifique com o sufixo @latest, por exemplo, textembedding-gecko@latest.

Para usar uma versão de modelo estável, especifique o número da versão de modelo, por exemplo, textembedding-gecko@003. Cada versão estável está disponível por seis meses após a data de lançamento da versão estável subsequente.

A tabela a seguir contém as versões de modelo estável disponíveis:

modelo textembedding-gecko	Data da versão	Data de desativação
textembedding-gecko@003	12 de dezembro de 2023	(31 de outubro de 2021).
textembedding-gecko@002	2 de novembro de 2023	(31 de outubro de 2021).
textembedding-gecko-multilingual@001	2 de novembro de 2023	(31 de outubro de 2021).
textembedding-gecko@001	7 de junho de 2023	(31 de outubro de 2021).
text-embedding-preview-0409	9 de abril de 2024	A ser atualizado para uma versão estável.
text-multilingual-embedding-preview-0409	9 de abril de 2024	A ser atualizado para uma versão estável.

Para mais informações, consulte Versões e ciclo de vida do modelo.

Corpo da solicitação

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

A API de embedding de PaLM da Vertex AI executa previsões on-line (em tempo real) para receber embeddings do texto de entrada.

A API aceita no máximo 3.072 tokens de entrada e gera embeddings de vetores com 768 dimensões. Use os parâmetros a seguir para o modelo de embeddings de texto textembedding-gecko. Para mais informações, consulte Visão geral de embeddings de texto.

Parâmetro	Descrição	Valores aceitáveis
`content`	O texto que você quer gerar embeddings.	Texto
`task_type`	O parâmetro "task_type" é definido como o aplicativo downstream pretendido para ajudar o modelo a produzir embeddings de melhor qualidade. É uma string que pode assumir um dos seguintes valores.	`RETRIEVAL_QUERY`, `RETRIEVAL_DOCUMENT`, `SEMANTIC_SIMILARITY`, `CLASSIFICATION`, `CLUSTERING`, `QUESTION_ANSWERING`, `FACT_VERIFICATION`.
`title`	O título do embedding.	Texto

Exemplo de solicitação

REST

Para testar um prompt de texto usando a API Vertex AI, envie uma solicitação POST para o endpoint do modelo do editor.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

PROJECT_ID: o ID do projeto.
TEXT: o texto para o qual você quer gerar embeddings.

Método 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 da solicitação:

{
  "instances": [
    { "content": "TEXT"}
  ],
}

Para enviar a solicitação, escolha uma destas opções:

curl

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que faz login automaticamente na CLI gcloud. É possível verificar a conta ativa atual executando gcloud auth list.

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

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

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

$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

Você receberá uma resposta JSON semelhante à amostra de resposta.

Python

Para saber como instalar ou atualizar o Python, consulte Instalar o SDK da Vertex AI para Python. Para mais informações, consulte a documentação de referência da 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]

Node.js

Antes de testar essa amostra, siga as instruções de configuração para Node.js Guia de início rápido da Vertex AI: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Node.js.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Java

Antes de testar essa amostra, siga as instruções de configuração para Java Guia de início rápido da Vertex AI: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Java.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Corpo da resposta

{
  "predictions": [
    {
      "embeddings": {
        "statistics": {
          "truncated": boolean,
          "token_count": integer
        },
        "values": [ number ]
      }
    }
  ]
}

Elemento de resposta	Descrição
`embeddings`	O resultado gerado a partir do texto de entrada.
`statistics`	As estatísticas calculadas a partir do texto de entrada.
`truncated`	Indica se o texto de entrada era maior que o número máximo permitido de tokens e truncados.
`tokenCount`	Número de tokens do texto de entrada.
`values`	O campo `values` contém os vetores de embedding correspondentes às palavras no texto de entrada.

Exemplo de resposta

{
  "predictions": [
    {
      "embeddings": {
        "values": [
          0.0058424929156899452,
          0.011848051100969315,
          0.032247550785541534,
          -0.031829461455345154,
          -0.055369812995195389,
          ...
        ],
        "statistics": {
          "token_count": 4,
          "truncated": false
        }
      }
    }
  ]
}