Incorporaciones de texto

Las incorporaciones para texto (textembedding-gecko) son el nombre del modelo que admite incorporaciones de texto. Las incorporaciones de texto son una técnica de PLN que convierte datos textuales en vectores numéricos que pueden procesar los algoritmos de aprendizaje automático, en especial los modelos grandes. Estas representaciones vectoriales están diseñadas para capturar el significado y el contexto semántico de las palabras que representan.

Hay algunas versiones disponibles para las incorporaciones. textembedding-gecko@003 es el modelo de incorporación estable más reciente con calidad de IA mejorada y textembedding-gecko-multilingual@001 es un modelo optimizado para una amplia gama de idiomas que no son inglés.

Para explorar este modelo en la consola, consulta la tarjeta de modelo Incorporaciones para texto en Model Garden.
Ir a Model Garden

Casos de uso

Búsqueda semántica: Las incorporaciones de texto se pueden usar para representar la consulta del usuario y el universo de documentos en un espacio vectorial de alta dimensión. Los documentos que son semánticamente más similares a la consulta del usuario tendrán una distancia más corta en el espacio vectorial y pueden clasificarse en una posición superior en los resultados de la búsqueda.

Clasificación de texto: Entrena un modelo que asigne las incorporaciones de texto a las etiquetas de categoría correctas (p. ej., gato vs. perro, spam vs. no spam). Una vez que el modelo se entrena, se puede usar para clasificar nuevas entradas de texto en una o más categorías según sus incorporaciones.

Solicitud HTTP

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

Versiones del modelo

Para usar la versión más reciente del modelo, especifica con el sufijo @latest, por ejemplo, textembedding-gecko@latest.

Para usar una versión del modelo estable, especifica el número de versión del modelo, por ejemplo, textembedding-gecko@003. Cada versión estable está disponible durante seis meses después de la fecha de lanzamiento de la versión estable posterior.

La siguiente tabla contiene las versiones disponibles del modelo estable:

modelo de textembedding-gecko Fecha de lanzamiento Fecha de descontinuación
textembedding-gecko@003 12 de diciembre de 2023 9 de octubre de 2024
textembedding-gecko@002 2 de noviembre de 2023 9 de octubre de 2024
textembedding-gecko-multilingual@001 2 de noviembre de 2023 9 de octubre de 2024
textembedding-gecko@001 7 de junio de 2023 9 de octubre de 2024
text-embedding-preview-0409 9 de abril de 2024 Para actualizarse a una versión estable.
text-multilingual-embedding-preview-0409 9 de abril de 2024 Para actualizarse a una versión estable.

Para obtener más información, consulta Versiones de modelo y ciclo de vida

Cuerpo de la solicitud

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

La API de incorporación de PaLM de Vertex AI realiza predicciones en línea (en tiempo real) para obtener incorporaciones del texto de entrada.

La API acepta un máximo de 3,072 tokens de entrada y genera incorporaciones de vectores de 768 dimensiones. Usa los siguientes parámetros para el modelo de incorporaciones textembedding-gecko. Para obtener más información, consulta Descripción general de las incorporaciones de texto.

Parámetro Descripción Valores aceptables

content

El texto para el que deseas generar incorporaciones. Texto

task_type

El parámetro “task_type” se define como la aplicación descendente deseada para ayudar al modelo a producir incorporaciones de mejor calidad. Es una cadena que puede tomar uno de los siguientes valores. RETRIEVAL_QUERY, RETRIEVAL_DOCUMENT, SEMANTIC_SIMILARITY, CLASSIFICATION, CLUSTERING, QUESTION_ANSWERING, FACT_VERIFICATION.

title

El título para la incorporación. Texto

Solicitud de muestra

REST

Para probar un mensaje de texto con la API de Vertex AI, envía una solicitud POST al extremo del modelo de publicador.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • PROJECT_ID: El ID del proyecto.
  • TEXT: El texto para el que deseas generar incorporaciones.

Método HTTP y URL: 

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

Cuerpo JSON de la solicitud:

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

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente 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

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente 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

Deberías recibir una respuesta JSON similar a la respuesta de ejemplo.

Python

Si deseas obtener información para instalar o actualizar el SDK de Python, consulta Instala el SDK de Vertex AI para Python. Si deseas obtener más información, consulta la documentación de referencia de la API de 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 probar este ejemplo, sigue las instrucciones de configuración para Node.js incluidas en la guía de inicio rápido de Vertex AI sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Vertex AI Node.js.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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 probar este ejemplo, sigue las instrucciones de configuración para Java incluidas en la guía de inicio rápido de Vertex AI sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Vertex AI Java.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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();
  }
}

Cuerpo de la respuesta

{
  "predictions": [
    {
      "embeddings": {
        "statistics": {
          "truncated": boolean,
          "token_count": integer
        },
        "values": [ number ]
      }
    }
  ]
}
Elemento de la respuesta Descripción
embeddings El resultado generado a partir del texto de entrada.
statistics Las estadísticas calculadas a partir del texto de entrada.
truncated Indica si el texto de entrada fue más largo que la cantidad máxima de tokens permitidos y si se truncó.
tokenCount Cantidad de tokens del texto de entrada.
values El campo values contiene los vectores de incorporación correspondientes a las palabras del texto de entrada.

Respuesta de muestra

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