Chat de texto

El modelo de base PaLM 2 for Chat (chat-bison) es un modelo de lenguaje grande (LLM) que se destaca en la comprensión del lenguaje, la generación del lenguaje y las conversaciones. Este modelo de chat está ajustado para realizar conversaciones naturales de varios turnos y es ideal para tareas de texto sobre código que requieren interacciones recíprocas.

Para tareas de texto que se puedan completar con una respuesta de la API (sin necesidad de una conversación continua), usa el modelo de texto.

Para explorar este modelo en la consola, consulta la tarjeta del modelo PaLM 2 para Chat en el jardín de modelos.
Ir a Model Garden

Casos de uso

  • Atención al cliente: Indica al modelo que responda como agentes de atención al cliente que solo hablen sobre el producto de tu empresa.

  • Asistencia técnica: Indica al modelo que interactúe con los clientes como agente de un centro de atención telefónica con parámetros específicos sobre cómo responder y qué no decir.

  • Personas y personajes: pídele al modelo que responda al estilo de una persona específica (“…en el estilo de Shakespeare”).

  • Complemento de sitio web: Crea un asistente conversacional para compras, viajes y otros casos de uso.

Para obtener más información, consulta Diseña indicaciones de chat.

Solicitud HTTP

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

Para obtener más información, consulta el método predict.

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 chat-bison.

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

En la tabla siguiente figuran las versiones de modelos estables disponibles:

modelo de chat-bison Fecha de lanzamiento Fecha de descontinuación
chat-bison@002 6 de diciembre de 2023 9 de octubre de 2024

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

Cuerpo de la solicitud

{
  "instances": [
    {
      "context":  string,
      "examples": [
        {
          "input": { "content": string },
          "output": { "content": string }
        }
      ],
      "messages": [
        {
          "author": string,
          "content": string,
        }
      ],
    }
  ],
  "parameters": {
    "temperature": number,
    "maxOutputTokens": integer,
    "topP": number,
    "topK": integer,
    "groundingConfig": string,
    "stopSequences": [ string ],
    "candidateCount": integer
    "logprobs": integer,
    "presencePenalty": float,
    "frequencyPenalty": float,
    "seed": integer
  }
}

En las llamadas a la API de chat, context, examples y messages se combinan a fin de formar la instrucción. En la siguiente tabla, se muestran los parámetros que debes configurar la API de PaLM de Vertex AI para el texto:

Parámetro Descripción Valores aceptables

context

(opcional)

El contexto define cómo responde el modelo a lo largo de la conversación. Por ejemplo, puedes usar el contexto para especificar las palabras que el modelo puede usar o no, los temas en los que se debe enfocar o que debe evitar, o el formato o estilo de respuesta. Texto

examples

(opcional)

Ejemplos para que el modelo aprenda a responder a la conversación.
[{
  "input": {"content": "provide content"},
  "output": {"content": "provide content"}
}]

messages

(obligatorio)

Historial de conversaciones proporcionado al modelo en forma estructurada de autor alternativo. Los mensajes aparecen en orden cronológico: el más antiguo primero y el último. Cuando el historial de mensajes hace que la entrada exceda la longitud máxima, los mensajes más antiguos se quitan hasta que todo el mensaje esté dentro del límite permitido.
[{
  "author": "user",
  "content": "user message"
}]

temperature

La temperatura se usa para muestreos 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

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

stopSequences

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_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.02.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.02.0

Minimum value: -2.0

Maximum value: 2.0

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 chat 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:

Para otros campos, consulta la tabla Cuerpo de la solicitud a continuación.

Método HTTP y URL:

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

Cuerpo JSON de la solicitud:

{
  "instances": [{
      "context":  "CONTEXT",
      "examples": [
       { 
          "input": {"content": "EXAMPLE_INPUT"},
          "output": {"content": "EXAMPLE_OUTPUT"}
       }],
      "messages": [
       { 
          "author": "AUTHOR",
          "content": "CONTENT",
       }],
   }],
  "parameters": {
    "temperature": TEMPERATURE,
    "maxOutputTokens": MAX_OUTPUT_TOKENS,
    "topP": TOP_P,
    "topK": TOP_K
  }
}

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/chat-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/chat-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 Vertex AI para 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.



def send_chat() -> str:
    from vertexai.language_models import ChatModel, InputOutputTextPair

    chat_model = ChatModel.from_pretrained("chat-bison@002")

    parameters = {
        "temperature": 0.2,
        "max_output_tokens": 256,
        "top_p": 0.95,
        "top_k": 40,
    }

    chat = chat_model.start_chat(
        context="My name is Miles. You are an astronomer, knowledgeable about the solar system.",
        examples=[
            InputOutputTextPair(
                input_text="How many moons does Mars have?",
                output_text="The planet Mars has two moons, Phobos and Deimos.",
            ),
        ],
    )

    response = chat.send_message(
        "How many planets are there in the solar system?", **parameters
    )
    print(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 = 'chat-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 = {
    context:
      'My name is Miles. You are an astronomer, knowledgeable about the solar system.',
    examples: [
      {
        input: {content: 'How many moons does Mars have?'},
        output: {
          content: 'The planet Mars has two moons, Phobos and Deimos.',
        },
      },
    ],
    messages: [
      {
        author: 'user',
        content: 'How many planets are there in the solar system?',
      },
    ],
  };
  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 chat prompt response');
  const predictions = response.predictions;
  console.log('\tPredictions :');
  for (const prediction of predictions) {
    console.log(`\t\tPrediction : ${JSON.stringify(prediction)}`);
  }
}

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 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;

// Send a Predict request to a large language model to test a chat prompt
public class PredictChatPromptSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String instance =
        "{\n"
            + "   \"context\":  \"My name is Ned. You are my personal assistant. My favorite movies"
            + " are Lord of the Rings and Hobbit.\",\n"
            + "   \"examples\": [ { \n"
            + "       \"input\": {\"content\": \"Who do you work for?\"},\n"
            + "       \"output\": {\"content\": \"I work for Ned.\"}\n"
            + "    },\n"
            + "    { \n"
            + "       \"input\": {\"content\": \"What do I like?\"},\n"
            + "       \"output\": {\"content\": \"Ned likes watching movies.\"}\n"
            + "    }],\n"
            + "   \"messages\": [\n"
            + "    { \n"
            + "       \"author\": \"user\",\n"
            + "       \"content\": \"Are my favorite movies based on a book series?\"\n"
            + "    }]\n"
            + "}";
    String parameters =
        "{\n"
            + "  \"temperature\": 0.3,\n"
            + "  \"maxDecodeSteps\": 200,\n"
            + "  \"topP\": 0.8,\n"
            + "  \"topK\": 40\n"
            + "}";
    String project = "YOUR_PROJECT_ID";
    String publisher = "google";
    String model = "chat-bison@001";

    predictChatPrompt(instance, parameters, project, publisher, model);
  }

  static void predictChatPrompt(
      String instance, String parameters, String project, String publisher, String model)
      throws IOException {
    PredictionServiceSettings predictionServiceSettings =
        PredictionServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .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)) {
      String location = "us-central1";
      final EndpointName endpointName =
          EndpointName.ofProjectLocationPublisherModelName(project, location, publisher, model);

      Value.Builder instanceValue = Value.newBuilder();
      JsonFormat.parser().merge(instance, instanceValue);
      List<Value> instances = new ArrayList<>();
      instances.add(instanceValue.build());

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

Cuerpo de la respuesta

{
  "predictions": [
    {
      "candidates": [
        {
          "author": string,
          "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": false,
        "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 Contenido de texto del mensaje de chat.
candidates El resultado del chat generado a partir de un mensaje determinado.
categories Los nombres visibles de las categorías de atributos de seguridad asociados con el contenido generado. El orden coincide con las puntuaciones.
author Etiqueta de autor para el turno.
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ó.
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.
safetyAttributes Una colección de categorías y sus puntuaciones de confianza asociadas. Asignación de 1:1 a candidates.
input_token_count Cantidad de tokens de entrada. Esta es la cantidad total de tokens en todos los mensajes, ejemplos y contexto.
output_token_count Cantidad de tokens de salida. Esta es la cantidad total de tokens en content de todos los candidatos en la respuesta.
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
      },
      "candidates": [
        {
          "author": "AUTHOR",
          "content": "RESPONSE"
        }
      ]
    }
  ]
}

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 de código y respuestas de muestra con la API de REST, consulta Ejemplos que usan la API de REST de transmisión.

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