Chat de texto

O modelo de base PaLM 2 para Chat (chat-bison) é um modelo de linguagem grande (LLM) que se destaca em compreensão de idiomas, geração de idiomas e conversas. Esse modelo de chat é ajustado para conduzir conversas naturais de vários turnos e é ideal para tarefas de texto sobre códigos que exigem interações de troca.

Para tarefas de texto que podem ser concluídas com uma resposta de API (sem a necessidade de conversa contínua), use o modelo de texto.

Para explorar esse modelo no console, consulte o card de modelo do PaLM 2 para o Chat no Model Garden.
Acessar o Model Garden

Casos de uso

Atendimento ao cliente: instrua o modelo a responder como agentes de atendimento ao cliente que falam apenas sobre o produto da sua empresa
Suporte técnico: instrua o modelo a interagir com os clientes como um agente de call center com parâmetros específicos sobre como responder e o que não dizer
Perfis e personagens: oriente o modelo para responder no estilo de uma pessoa específica ("no estilo de Shakespeare")
Complementar do site: crie um assistente de conversa para compras, viagens e outros casos de uso

Para mais informações, consulte Criar prompts de chat.

Solicitação HTTP

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

Para mais informações, consulte o método predict.

Versões do modelo

Para usar a versão de modelo mais recente, especifique o nome do modelo sem um número de versão. Por exemplo, chat-bison.

Para usar uma versão de modelo estável, especifique o número da versão de modelo, por exemplo, chat-bison@002. 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 de chat-bison	Data da versão	Data de desativação
chat-bison@002	6 de dezembro de 2023	9 de outubro de 2024
chat-bison@001	10 de julho de 2023	6 de julho de 2024

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

Corpo da solicitação

{
  "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
  }
}

Para chamadas de API de chat, context, examples e messages são combinados para formar a solicitação. A tabela a seguir mostra os parâmetros que você precisa configurar para a API Vertex AI PaLM para texto:

Parâmetro	Descrição	Valores aceitáveis
`context` (opcional)	O contexto ajusta as respostas do modelo ao longo da conversa. Por exemplo, com o contexto, é possível especificar as palavras que podem ser usadas pelo modelo, os assuntos a serem tratados ou evitados, assim como o formato ou o estilo das respostas.	Texto
`examples` (opcional)	Exemplos do modelo para saber como responder à conversa.	[{ "input": {"content": "provide content"}, "output": {"content": "provide content"} }]
`messages` (obrigatório)	Histórico de conversas fornecido ao modelo em um formulário estruturado de autor alternativo. As mensagens aparecem em ordem cronológica: a mais antiga primeiro e a mais recente por último. Quando o histórico de mensagens faz com que a entrada exceda o tamanho máximo, as mensagens mais antigas são removidas até que todo o prompt esteja dentro do limite permitido.	[{ "author": "user", "content": "user message" }]
`temperature`	A temperatura é usada para amostragem durante a geração da resposta, que ocorre quando `topP` e `topK` são aplicados. A temperatura controla o grau de aleatoriedade na seleção do token. Temperaturas mais baixas são boas para solicitações que exigem uma resposta menos aberta ou criativa, enquanto temperaturas mais altas podem levar a resultados mais diversos ou criativos. Uma temperatura de `0` significa que os tokens de maior probabilidade são sempre selecionados. Nesse caso, as respostas para uma determinada solicitação são, na maioria das vezes, deterministas, mas uma pequena variação ainda é possível. Se o modelo retornar uma resposta muito genérica, muito curta ou se o modelo fornecer uma resposta alternativa, tente aumentar a temperatura.	`0.0–1.0` `Default: 0.0`
`maxOutputTokens`	Número máximo de tokens que podem ser gerados na resposta. Um token tem cerca de quatro caracteres. 100 tokens correspondem a cerca de 60 a 80 palavras. Especifique um valor mais baixo para respostas mais curtas e um valor mais alto para respostas potencialmente mais longas.	`1–2048` `Default: 1024`
`topK`	O Top-K muda a forma como o modelo seleciona tokens para saída. Um top-K de `1` significa que o próximo token selecionado é o mais provável entre todos os tokens no vocabulário do modelo (também chamado de decodificação gananciosa), enquanto um top-K de `3` significa que o próximo token está selecionado entre os três tokens mais prováveis usando a temperatura. Para cada etapa da seleção de tokens, são amostrados os tokens top-K com as maiores probabilidades. Em seguida, os tokens são filtrados com base no valor de top-P com o token final selecionado por meio da amostragem de temperatura. Especifique um valor mais baixo para respostas menos aleatórias e um valor mais alto para respostas mais aleatórias.	`1–40` `Default: 40`
`topP`	O Top-P muda a forma como o modelo seleciona tokens para saída. Os tokens são selecionados do mais provável (veja o top-K) para o menos provável até que a soma das probabilidades seja igual ao valor do top-P. Por exemplo, se os tokens A, B e C tiverem uma probabilidade de 0,3, 0,2 e 0,1 e o valor de top-P for `0.5`, o modelo selecionará A ou B como token seguinte usando temperatura e exclui C como candidato. Especifique um valor mais baixo para respostas menos aleatórias e um valor mais alto para respostas mais aleatórias.	`0.0–1.0` `Default: 0.95`
`stopSequences`	Especifica uma lista de strings que instrui o modelo a parar de gerar texto se uma das strings for encontrada na resposta. Se uma string aparecer várias vezes na resposta, a resposta truncará quando for encontrada pela primeira vez. As strings diferenciam maiúsculas de minúsculas. Por exemplo, se a resposta a seguir for retornada quando `stopSequences` não for especificado: `public static string reverse(string myString)` A resposta retornada com `stopSequences` definida como `["Str", "reverse"]` é: `public static string`	`default: []`
`groundingConfig`	O embasamento permite referenciar dados específicos ao usar modelos de linguagem. Quando você embasa um modelo, ele pode referenciar dados internos, confidenciais e específicos do repositório e os incluir na resposta. Apenas repositórios de dados da Vertex AI para Pesquisa são compatíveis.	O caminho precisa seguir o formato: `projects/{project_id}/locations/global/collections/{collection_name}/dataStores/{DATA_STORE_ID}`
`candidateCount`	O número de variações de resposta a serem retornadas.	`1–4` `Default: 1`
`logprobs`	Retorna os principais tokens `logprobs` candidatos com as respectivas probabilidades de registro em cada etapa de geração. Os tokens escolhidos e as probabilidades de registro deles em cada etapa são sempre retornados. O token escolhido pode ou não estar entre os principais candidatos de `logprobs`.	`0-5`
`frequencyPenalty`	Valores positivos penalizam tokens que aparecem repetidamente no texto gerado, diminuindo a probabilidade de repetir conteúdo. Os valores aceitáveis são `-2.0`—`2.0`.	`Minimum value: -2.0` `Maximum value: 2.0`
`presencePenalty`	Valores positivos penalizam tokens que já aparecem no texto gerado, aumentando a probabilidade de gerar conteúdo mais diversificado. Os valores aceitáveis `-2.0`—`2.0`.	`Minimum value: -2.0` `Maximum value: 2.0`
`seed`	O decodificador gera ruído aleatório com um gerador de número pseudoaleatório. O ruído de temperatura * é adicionado aos logits antes da amostragem. O gerador de número pseudoaleatório (prng) usa uma seed como entrada e gera a mesma saída com a mesma seed. Se a seed não for definida, a seed usada no decodificador não será determinista. Portanto, o ruído aleatório gerado não será determinista. Se a seed for definida, o ruído aleatório gerado será determinista.	`Optional`

Exemplo de solicitação

REST

Para testar um chat 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.

Para outros campos, consulte a tabela Corpo da solicitação abaixo.

Método HTTP e URL:

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

Corpo JSON da solicitação:

{
  "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 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/chat-bison:predict"

PowerShell

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 . É 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:

$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

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

Python

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

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

Corpo da resposta

{
  "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 resposta	Descrição
`content`	Conteúdo de texto da mensagem de chat.
`candidates`	O resultado do chat gerado com a mensagem fornecida.
`categories`	Os nomes de exibição das categorias de atributo de segurança associadas ao conteúdo gerado. A ordem corresponde às pontuações.
`author`	Tag do autor para a vez.
`scores`	As pontuações de confiança de cada categoria, maior valor significa maior confiança.
`blocked`	Uma flag que indica se a entrada ou saída do modelo foi bloqueada.
`startIndex`	Índice na saída de previsão em que a citação começa (inclusive). Precisa ser >= 0 e < end_index.
`endIndex`	Índice na saída da previsão em que a citação termina (exclusiva). Precisa ser > start_index e < len(output).
`url`	URL associado a esta citação. Se presente, esse URL está vinculado à página da Web da fonte da citação. Os possíveis URLs incluem sites de notícias, repositórios do GitHub etc.
`title`	Título associado a esta citação. Se presente, refere-se ao título da fonte desta citação. Os possíveis títulos incluem títulos de notícias, títulos de livros etc.
`license`	Licença associada a esta recitação. Se estiver presente, refere-se à licença da fonte dessa citação. As possíveis licenças incluem licenças de código, como a licença mit.
`publicationDate`	Data de publicação associada a esta citação. Se presente, refere-se à data em que a fonte da citação foi publicada. Os formatos possíveis são AAAA, AAAA-MM, AAAA-MM-DD.
`safetyAttributes`	Uma coleção de categorias e as pontuações de confiança associadas a elas. Mapeamento 1-1 para `candidates`.
`input_token_count`	Número de tokens de entrada. Esse é o número total de tokens em todas as mensagens, exemplos e contextos.
`output_token_count`	Número de tokens de saída. Esse é o número total de tokens em `content` em todos os candidatos na resposta.
`tokens`	Os tokens de amostra.
`tokenLogProbs`	Probabilidades de registro dos tokens de amostra.
`topLogProb`	Os tokens candidatos mais prováveis e as probabilidades de registro deles em cada etapa.
`logprobs`	Resultados do parâmetro `logprobs`. Mapeamento de 1-1 para "candidatos".

Exemplo de resposta

{
  "predictions": [
    {
      "citationMetadata": {
        "citations": []
      },
      "safetyAttributes": {
        "scores": [
          0.1
        ],
        "categories": [
          "Finance"
        ],
        "blocked": false
      },
      "candidates": [
        {
          "author": "AUTHOR",
          "content": "RESPONSE"
        }
      ]
    }
  ]
}

Resposta de stream de modelos de IA generativa

Os parâmetros são os mesmos para streaming e solicitações sem streaming para as APIs.

Para conferir exemplos de solicitações de código e respostas usando a API REST, consulte Exemplos usando a API REST de streaming.

Para conferir exemplos de código de solicitações e respostas usando o SDK da Vertex AI para Python, consulte Exemplos que usam o SDK da Vertex AI para Python para streaming.