Texto

El modelo de base PaLM 2 for Text (text-bison, text-unicorn) está optimizado para una variedad de tareas de lenguaje natural, como el análisis de opiniones, la extracción de entidades y la creación de contenido. Los tipos de contenido que el modelo PaLM 2 for Text puede crear incluyen resúmenes de documentos, respuestas a preguntas y etiquetas que clasifican contenido.

El modelo de PaLM 2 for Text es ideal para tareas que se pueden completar con una sola respuesta de la API, sin la necesidad de mantener una conversación continua. Para tareas de texto que requieren interacciones de ida y vuelta, usa la IA generativa en la API de Vertex AI para chat.

Para explorar los modelos en la consola, elije la tarjeta del modelo PaLM 2 para el texto en el jardín de modelos.
Ir a Model Garden

Casos de uso

Resúmenes: crea una versión más corta de un documento que incorpore la información pertinente del texto original. Por ejemplo, es posible que quieras resumir un capítulo de un libro de texto. O bien, puedes crear una descripción concisa del producto a partir de un párrafo extenso que describa el producto en detalle.
Búsqueda de respuestas: proporciona respuestas a preguntas en texto. Por ejemplo, puedes automatizar la creación de un documento de preguntas frecuentes desde el contenido de la base de conocimiento.
Clasificación: asigna una etiqueta al texto proporcionado. Por ejemplo, una etiqueta puede aplicarse a un texto que describa su corrección gramatical.
Análisis de opiniones: esta es una forma de clasificación que identifica la opinión del texto. La opinión se convierte en una etiqueta que se aplica al texto. Por ejemplo, la opinión del texto puede tener opiniones como enojo o satisfacción, o polaridades como positivas o negativas.
Extracción de entidades: extrae información adicional del texto. Por ejemplo, puedes extraer el nombre de una película del texto de un artículo.

Para obtener más información sobre cómo diseñar mensajes de texto, consulta Diseña instrucciones de texto.

Solicitud HTTP

POST https://us-central1-aiplatform.googleapis.com/v1/projects/{PROJECT_ID}/locations/us-central1/publishers/google/models/text-bison:predict

Consulta el método predict para obtener más información.

Versiones del modelo

Para usar la versión más reciente del modelo, especifica el nombre del modelo sin un número de versión, por ejemplo text-bison.

Para usar una versión del modelo estable, especifica el número de versión del modelo, por ejemplo, text-bison@002. 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 text-bison	Fecha de lanzamiento	Fecha de descontinuación
text-bison@002	6 de diciembre de 2023	9 de octubre de 2024
text-bison@001	7 de junio de 2023	6 julio de 2024

modelo unicornio de texto	Fecha de lanzamiento	Fecha de descontinuación
texto-unicornio@001	30 de noviembre de 2023	No antes del 30 de noviembre de 2024

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

Cuerpo de la solicitud

{
  "instances": [
    {
      "prompt": string
    }
  ],
  "parameters": {
    "temperature": number,
    "maxOutputTokens": integer,
    "topK": integer,
    "topP": number,
    "groundingConfig": string,
    "stopSequences": [ string ],
    "candidateCount": integer,
    "logprobs": integer,
    "presencePenalty": float,
    "frequencyPenalty": float,
    "echo": boolean,
    "seed": integer
  }
}

Usa los siguientes parámetros para el modelo de texto text-bison. Para obtener más información, consulta Diseña indicaciones de texto.

Parámetro	Descripción	Valores aceptables
`prompt`	Entrada de texto para generar una respuesta del modelo. Las instrucciones pueden incluir predicado, preguntas, sugerencias, instrucciones o ejemplos.	Texto
`temperature`	La temperatura se usa para las muestras durante la generación de respuesta, que se genera cuando se aplican `topP` y `topK`. La temperatura controla el grado de aleatorización en la selección de tokens. Las temperaturas más bajas son buenas para los mensajes que requieren una respuesta menos abierta o de creativa, mientras que las temperaturas más altas pueden generar resultados más diversos o creativos. Una temperatura de `0` significa que siempre se seleccionan los tokens de probabilidad más alta. En este caso, las respuestas para un mensaje determinado son, en su mayoría, deterministas, pero es posible que haya una pequeña cantidad de variación. Si el modelo muestra una respuesta demasiado genérica, demasiado corta o el modelo proporciona una respuesta de resguardo, intenta aumentar la temperatura.	`0.0–1.0` `Default: 0.0`
`maxOutputTokens`	Cantidad máxima de tokens que se pueden generar en la respuesta. Un token tiene casi cuatro caracteres. 100 tokens corresponden a casi 60 u 80 palabras. Especifica un valor más bajo para las respuestas más cortas y un valor más alto para las respuestas potencialmente más largas.	`1–2048` para text-bison (más reciente) `1–1024` para text-bison@002 `Default: 1024`
`topK`	El parámetro Top-K cambia la manera en la que el modelo selecciona los tokens para el resultado. K superior a `1` significa que el siguiente token seleccionado es el más probable entre todos los tokens en el vocabulario del modelo (también llamado decodificación voraz), mientras que el K superior a `3` significa que el siguiente token se selecciona de los tres tokens más probables mediante la temperatura. Para cada paso de selección de tokens, se muestran los tokens de K superior con las probabilidades más altas. Luego, los tokens se filtran según el superior con el token final seleccionado mediante el muestreo de temperatura. Especifica un valor más bajo para respuestas menos aleatorias y un valor más alto para respuestas más aleatorias.	`1–40` `Default: 40`
`topP`	Top-P cambia la manera en la que el modelo selecciona tokens para la salida. Los tokens se seleccionan desde el más alto (consulta K superior) hasta el menos probable, hasta que la suma de sus probabilidades sea igual al valor de P superior. Por ejemplo, si los tokens A, B y C tienen una probabilidad de 0.3, 0.2 y 0.1, y el valor P superior es `0.5`, el modelo elegirá A o B como el siguiente token mediante la temperatura y excluirá a C como candidato. Especifica un valor más bajo para respuestas menos aleatorias y un valor más alto para respuestas más aleatorias.	`0.0–1.0` `Default: 0.95`
`stopSequence`	Especifica una lista de cadenas que le indica al modelo que deje de generar texto si se encuentra una de las cadenas en la respuesta. Si una cadena aparece varias veces en la respuesta, la respuesta trunca el lugar en que se encontró por primera vez. Las cadenas distinguen entre mayúsculas y minúsculas. Por ejemplo, si la siguiente es la respuesta que se muestra cuando no se especifica `stopSequences`: `public static string reverse(string myString)` Luego, la respuesta que se muestra con `stopSequences` configurada como `["Str", "reverse"]` es la siguiente: `public static string`	`default: []`
`groundingConfig`	Los fundamentos te permiten hacer referencia a datos específicos cuando usas modelos de lenguaje. Cuando basas un modelo, este puede hacer referencia a datos internos, confidenciales y, de otro modo, específicos de tu repositorio, y también incluir los datos en la respuesta. Solo se admiten los almacenes de datos de Vertex AI Search.	La ruta debe seguir el siguiente formato: `projects/{project_number_or_id}/locations/global/collections/{collection_name}/dataStores/{DATA_STORE_ID}`.
`candidateCount`	La cantidad de variaciones de respuesta que se mostrarán.	`1–4` `Default: 1`
`logprobs`	Devuelve los tokens candidatos de `logprobs` principales más probables con sus probabilidades de registro en cada paso de generación. Los tokens elegidos y sus probabilidades de registro en cada paso siempre se muestran. El token elegido puede o no estar en los `logprobs` principales.	`0-5`
`frequencyPenalty`	Los valores positivos penalizan los tokens que aparecen repetidamente en el texto generado, lo que disminuye la probabilidad de repetir contenido. Los valores aceptables son: `-2.0`—`2.0`	`Minimum value: -2.0` `Maximum value: 2.0`
`presencePenalty`	Los valores positivos penalizan los tokens que ya aparecen en el texto generado, lo que aumenta la probabilidad de generar contenido más diverso. Los valores aceptables son: `-2.0`—`2.0`	`Minimum value: -2.0` `Maximum value: 2.0`
`echo`	Si es verdadero, el mensaje se repite en el texto generado.	`Optional`
`seed`	El decodificador genera ruido aleatorio con un generador de números pseudoaleatorios, se agrega temperatura * ruido a los logits antes del muestreo. El generador de números pseudoaleatorios (prng) toma un valor inicial como entrada y genera el mismo resultado con el mismo valor inicial. Si no se establece el valor inicial, el valor inicial usado en el decodificador no será determinista, por lo que el ruido aleatorio generado no será determinístico. Si se establece el valor inicial, el ruido aleatorio generado será determinístico.	`Optional`

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.

Para otros campos, consulta la tabla Cuerpo de la solicitud.

Método HTTP y URL:

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

Cuerpo JSON de la solicitud:

{
  "instances": [
    { "prompt": "Give me ten interview questions for the role of program manager."}
  ],
  "parameters": {
    "temperature": 0.2,
    "maxOutputTokens": 256,
    "topK": 40,
    "topP": 0.95,
    "logprobs": 2
  }
}

Para enviar tu solicitud, elige una de estas opciones:

curl

Nota: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login, o a través del uso de Cloud Shell, que accede de forma automática a la CLI de gcloud. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

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/text-bison: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/text-bison: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.

import vertexai
from vertexai.language_models import TextGenerationModel

def interview(
    temperature: float,
    project_id: str,
    location: str,
) -> str:
    """Ideation example with a Large Language Model"""

    vertexai.init(project=project_id, location=location)
    # TODO developer - override these parameters as needed:
    parameters = {
        "temperature": temperature,  # Temperature controls the degree of randomness in token selection.
        "max_output_tokens": 256,  # Token limit determines the maximum amount of text output.
        "top_p": 0.8,  # Tokens are selected from most probable to least until the sum of their probabilities equals the top_p value.
        "top_k": 40,  # A top_k of 1 means the selected token is the most probable among all tokens.
    }

    model = TextGenerationModel.from_pretrained("text-bison@002")
    response = model.predict(
        "Give me ten interview questions for the role of program manager.",
        **parameters,
    )
    print(f"Response from Model: {response.text}")

    return response.text

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.

/**
 * 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 = 'text-bison@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 prompt = {
    prompt:
      'Give me ten interview questions for the role of program manager.',
  };
  const instanceValue = helpers.toValue(prompt);
  const instances = [instanceValue];

  const parameter = {
    temperature: 0.2,
    maxOutputTokens: 256,
    topP: 0.95,
    topK: 40,
  };
  const parameters = helpers.toValue(parameter);

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

  // Predict request
  const response = await predictionServiceClient.predict(request);
  console.log('Get text prompt response');
  console.log(response);
}

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.


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 PredictTextPromptSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // Details of designing text prompts for supported large language models:
    // https://cloud.google.com/vertex-ai/docs/generative-ai/text/text-overview
    String instance =
        "{ \"prompt\": " + "\"Give me ten interview questions for the role of program manager.\"}";
    String parameters =
        "{\n"
            + "  \"temperature\": 0.2,\n"
            + "  \"maxOutputTokens\": 256,\n"
            + "  \"topP\": 0.95,\n"
            + "  \"topK\": 40\n"
            + "}";
    String project = "YOUR_PROJECT_ID";
    String location = "us-central1";
    String publisher = "google";
    String model = "text-bison@001";

    predictTextPrompt(instance, parameters, project, location, publisher, model);
  }

  // Get a text prompt from a supported text model
  public static void predictTextPrompt(
      String instance,
      String parameters,
      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)) {
      final EndpointName endpointName =
          EndpointName.ofProjectLocationPublisherModelName(project, location, publisher, model);

      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      Value.Builder instanceValue = Value.newBuilder();
      JsonFormat.parser().merge(instance, instanceValue);
      List<Value> instances = new ArrayList<>();
      instances.add(instanceValue.build());

      // Use Value.Builder to convert instance to a dynamically typed value that can be
      // processed by the service.
      Value.Builder parameterValueBuilder = Value.newBuilder();
      JsonFormat.parser().merge(parameters, parameterValueBuilder);
      Value parameterValue = parameterValueBuilder.build();

      PredictResponse predictResponse =
          predictionServiceClient.predict(endpointName, instances, parameterValue);
      System.out.println("Predict Response");
      System.out.println(predictResponse);
    }
  }
}

Cuerpo de la respuesta

{
  "predictions":[
    {
      "content": string,
      "citationMetadata": {
        "citations": [
          {
            "startIndex": integer,
            "endIndex": integer,
            "url": string,
            "title": string,
            "license": string,
            "publicationDate": string
          }
        ]
      },
      "logprobs": {
        "tokenLogProbs": [ float ],
        "tokens": [ string ],
        "topLogProbs": [ { map<string, float> } ]
      },
      "safetyAttributes": {
        "categories": [ string ],
        "blocked": boolean,
        "scores": [ float ],
        "errors": [ int ]
      }
    }
  ],
  "metadata": {
    "tokenMetadata": {
      "input_token_count": {
        "total_tokens": integer,
        "total_billable_characters": integer
      },
      "output_token_count": {
        "total_tokens": integer,
        "total_billable_characters": integer
      }
    }
  }
}

Elemento de la respuesta	Descripción
`content`	El resultado generado a partir del texto de entrada.
`categories`	Los nombres visibles de las categorías de atributos de seguridad asociados con el contenido generado. El orden coincide con las puntuaciones.
`scores`	Las puntuaciones de confianza de cada categoría, un valor más alto significa más confianza.
`blocked`	Una marca que indica si la entrada o salida del modelo se bloqueó.
`errors`	Un código de error que identifica por qué se bloqueó la entrada o la salida. Para obtener una lista de códigos de error, consulta Filtros y atributos de seguridad.
`startIndex`	Índice en el resultado de la predicción en el que comienza la cita (inclusive). Debe ser >= 0 y < end_index.
`endIndex`	Índice en el resultado de la predicción en el que finaliza la cita (exclusivo). Debe ser > start_index y < len(output).
`url`	URL asociada con esta cita. Si está presente, esta URL vincula a la página web de la fuente de esta cita. Las URLs posibles incluyen sitios web de noticias, repositorios de GitHub, etcétera.
`title`	Título asociado a esta cita. Si está presente, hace referencia al título de la fuente de esta cita. Los posibles títulos incluyen títulos de noticias, de libros, etcétera.
`license`	Licencia asociada con esta repetición. Si está presente, hace referencia a la licencia de la fuente de esta cita. Las posibles licencias incluyen licencias de código, p. ej., Licencia MIT.
`publicationDate`	Es la fecha de publicación asociada con esta cita. Si está presente, hace referencia a la fecha en la que se publicó la fuente de esta cita. Los formatos posibles son AAAA, AAAA-MM y AAAA-MM-DD.
`input_token_count`	Cantidad de tokens de entrada. Esta es la cantidad total de tokens en todos los mensajes, prefijos y sufijos.
`output_token_count`	Cantidad de tokens de salida. Esta es la cantidad total de tokens en `content` en todas las predicciones.
`tokens`	Los tokens de muestra.
`tokenLogProbs`	Las probabilidades de registro de los tokens de muestra.
`topLogProb`	Los tokens de candidatos más probables y sus probabilidades de registro en cada paso.
`logprobs`	Resultados del parámetro “logprobs”. Asignación de 1 a 1 a “candidatos”.

Respuesta de muestra

{
  "predictions": [
    {
      "citationMetadata":{
        "citations": [ ]
      },
      "safetyAttributes":{
        "scores": [
          0.1
        ],
        "categories": [
          "Finance"
        ],
        "blocked": false
      },
      "content":"1. What is your experience with project management?\n2. What are your strengths and weaknesses as a project manager?\n3. How do you handle conflict and difficult situations?\n4. How do you communicate with stakeholders?\n5. How do you stay organized and on track?\n6. How do you manage your time effectively?\n7. What are your goals for your career?\n8. Why are you interested in this position?\n9. What are your salary expectations?\n10. What are your availability and start date?",
      "logprobs": {
        "tokenLogProbs": [
          -0.1,
          -0.2
        ],
        "tokens": [
          "vertex",
          " rocks!"
        ],
        "topLogProbs": [
          {
            "vertex": -0.1,
            "hello": -0.2
          },
          {
            " rocks!": -0.2,
            " world!": -0.3
          }
        ]
      }
    },
    "metadata": {
      "tokenMetadata": {
        "outputTokenCount": {
          "totalTokens": 153,
          "totalBillableCharacters": 537
        },
        "inputTokenCount": {
          "totalBillableCharacters": 54,
          "totalTokens": 12
        }
      }
    }
  ]
}

Respuesta de transmisión desde modelos de IA generativa

Los parámetros son los mismos para las solicitudes de transmisión y las de no transmisión a las APIs.

Para ver solicitudes y respuestas de código de muestra mediante la API de REST, consulta Ejemplos mediante la API de REST.

Si deseas ver las solicitudes y respuestas de código de muestra con el SDK de Vertex AI para Python, consulta Ejemplos que usan el SDK de Vertex AI para Python.