Probar mensajes de chat

Vertex AI te permite usar Generative AI Studio para probar instrucciones en la consola de Google Cloud, la API de Vertex AI y el SDK de Vertex AI para Python. En esta página, se muestra cómo probar las instrucciones de chat con cualquiera de estas interfaces.

Para obtener más información sobre cómo diseñar las instrucciones de chat, consulta Instrucciones de chat.

Probar mensajes de chat

Para probar las instrucciones de chat, elige uno de los siguientes métodos.

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.
  • CONTEXT: Opcional El contexto pueden ser instrucciones que le das al modelo sobre cómo debe responder o sobre la información que usa o referencias para generar una respuesta. Agrega información contextual en tu instrucción si necesitas dar información al modelo o restringir los límites de las respuestas a solo lo que está dentro del contexto.
  • Ejemplos opcionales: Los ejemplos son una lista de mensajes estructurados para el modelo a fin de aprender a responder a la conversación.
    • EXAMPLE_INPUT: Ejemplo de un mensaje.
    • EXAMPLE_OUTPUT: Ejemplo de la respuesta ideal.
  • Mensajes: 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. Debe haber un número impar de mensajes (pares AUTHOR-CONTENT) para que el modelo genere una respuesta.
    • AUTHOR: El autor del mensaje.
    • CONTENT: El contenido del mensaje.
  • 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.

  • MAX_OUTPUT_TOKENS: Cantidad máxima de tokens que se pueden generar en la respuesta. Un token tiene aproximadamente 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.

  • TOP_P: P superior 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.

  • TOP_K: K superior 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.

HTTP method and 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 que se muestra a continuación:

Ejemplo del comando curl

MODEL_ID="chat-bison"
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": [{
      "context":  "My name is Ned. You are my personal assistant. My favorite movies are Lord of the Rings and Hobbit.",
      "examples": [ {
          "input": {"content": "Who do you work for?"},
          "output": {"content": "I work for Ned."}
       },
       {
          "input": {"content": "What do I like?"},
          "output": {"content": "Ned likes watching movies."}
       }],
      "messages": [
       {
          "author": "user",
          "content": "Are my favorite movies based on a book series?",
       },
       {
          "author": "bot",
          "content": "Yes, your favorite movies, The Lord of the Rings and The Hobbit, are based on book series by J.R.R. Tolkien.",
       },
       {
          "author": "user",
          "content": "When were these books published?",
       }],
   }],
  "parameters": {
    "temperature": 0.3,
    "maxOutputTokens": 200,
    "topP": 0.8,
    "topK": 40
  }
}'

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 vertexai.language_models import ChatModel, InputOutputTextPair

def science_tutoring(temperature: float = 0.2) -> None:
    chat_model = ChatModel.from_pretrained("chat-bison@001")

    # 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.95,  # 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.
    }

    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(f"Response from Model: {response.text}")

    return response

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

C#

Antes de probar este ejemplo, sigue las instrucciones de configuración para C# 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 C#.

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. 


using Google.Cloud.AIPlatform.V1;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using Value = Google.Protobuf.WellKnownTypes.Value;

public class PredictChatPromptSample
{
    public string PredictChatPrompt(
        string projectId = "your-project-id",
        string locationId = "us-central1",
        string publisher = "google",
        string model = "chat-bison@001"
    )
    {
        // Initialize client that will be used to send requests.
        // This client only needs to be created once,
        // and can be reused for multiple requests.
        var client = new PredictionServiceClientBuilder
        {
            Endpoint = $"{locationId}-aiplatform.googleapis.com"
        }.Build();

        // Configure the parent resource.
        var endpoint = EndpointName.FromProjectLocationPublisherModel(projectId, locationId, publisher, model);

        // Initialize request argument(s).
        var prompt = "How many planets are there in the solar system?";

        // You can construct Protobuf from JSON.
        var instanceJson = JsonConvert.SerializeObject(new
        {
            context = "My name is Miles. You are an astronomer, knowledgeable about the solar system.",
            examples = new[]
            {
                new
                {
                    input = new { content = "How many moons does Mars have?" },
                    output = new { content = "The planet Mars has two moons, Phobos and Deimos." }
                }
            },
            messages = new[]
            {
                new
                {
                    author = "user",
                    content = prompt
                }
            }
        });
        var instance = Value.Parser.ParseJson(instanceJson);

        var instances = new List<Value>
        {
            instance
        };

        // You can construct Protobuf from JSON.
        var parametersJson = JsonConvert.SerializeObject(new
        {
            temperature = 0.3,
            maxDecodeSteps = 200,
            topP = 0.8,
            topK = 40
        });
        var parameters = Value.Parser.ParseJson(parametersJson);

        // Make the request.
        var response = client.Predict(endpoint, instances, parameters);

        // Parse the response and return the content.
        var content = response.Predictions.First().StructValue.Fields["candidates"].ListValue.Values[0].StructValue.Fields["content"].StringValue;
        Console.WriteLine($"Content: {content}");
        return content;
    }
}

Console

Para usar Generative AI Studio con el fin de probar una instrucción de chat en la consola de Google Cloud, haz lo siguiente:

  1. En la sección Vertex AI de la consola de Google Cloud, ve a la página Vertex AI Studio.

    Ir a Vertex AI Studio

  2. Haz clic en la pestaña Empezar.
  3. Haz clic en Chat de texto.

  4. Configura el mensaje de la siguiente manera:

    • Contexto: Ingresa las instrucciones para la tarea que deseas que realice el modelo y, además, incluye cualquier información contextual a la que el modelo haga referencia.
    • Ejemplos: En el caso de mensajes poco tomas, agrega ejemplos de entrada y salida que muestren los patrones de comportamiento que el modelo debe imitar.

  5. Configura el modelo y los parámetros:

    • Modelo: Selecciona el modelo que deseas usar.

    • Temperatura: Usa el control deslizante o el cuadro de texto para ingresar un valor de temperatura.

      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.

    • Límite de token: Usa el control deslizante o el cuadro de texto con el fin de ingresar un valor para el límite máximo de salida.

      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.

    • K superior: Usa el control deslizante o el cuadro de texto con el fin de ingresar un valor para K superior.

      K superior cambia la manera en que el modelo selecciona tokens para la salida. 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.

    • P superior: Usa el control deslizante o el cuadro de texto con el fin de ingresar un valor de P superior. Los tokens se seleccionan del más probable al menos hasta que la suma de sus probabilidades sea igual al valor de P superior. Para obtener los resultados menos variables, establece top-P como 0.
  6. Ingresa un mensaje en el cuadro de mensaje para iniciar una conversación con el chatbot. El chatbot usa los mensajes anteriores como contexto para las respuestas nuevas.
  7. Para guardar el mensaje en Mis mensajes, haz clic en Guardar (opcional).
  8. Para obtener el código de Python o un comando curl para tu instrucción, haz clic en Ver código (opcional).
  9. Opcional: Para borrar todos los mensajes anteriores, haz clic en Borrar conversación .

Respuesta de transmisión desde el modelo de chat

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.

¿Qué sigue?