Texto

Atenção: os modelos de linguagem PaLM (Pathways Language Model) foram descontinuados. A partir de 9 de outubro de 2024, não será mais possível acessá-los em novos projetos do Google Cloud, e o acesso a eles será removido para todos os projetos em 9 de abril de 2025. Se você é um usuário novo, recomendamos usar o Gemini. Se você já é usuário do PaLM, consulte Migrar do PaLM 2 para o Gemini.

Os modelos de fundação do PaLM 2 para texto (text-bison, text-unicorn) são otimizados para várias tarefas de linguagem natural, como análise de sentimento, extração de entidades e criação de conteúdo. Os tipos de conteúdo que os modelos PaLM 2 para texto podem criar incluem resumos de documentos, respostas a perguntas e rótulos que classificam o conteúdo.

Os modelos PaLM 2 para texto são ideais para tarefas que podem ser concluídas com uma resposta da API, sem a necessidade de conversa contínua. Para tarefas de texto que exigem interações de ida e volta, use a IA generativa na API do Vertex AI para chat.

Para explorar os modelos no console, selecione o card de modelo PaLM 2 para texto no Model Garden.
Acessar o Model Garden

Casos de uso

• Resumo: crie uma versão mais curta de um documento que incorpore informações pertinentes do texto original. Por exemplo, é possível resumir um capítulo de um livro didático. Também é possível criar uma descrição sucinta do produto a partir de um parágrafo longo que descreva o produto em detalhes.

• Respostas a perguntas: responda a perguntas no texto. Por exemplo, é possível automatizar a criação de um documento de Perguntas frequentes a partir do conteúdo da base de conhecimento.

• Classificação: atribua um rótulo ao texto fornecido. Por exemplo, um rótulo pode ser aplicado a textos que descrevem como ele é gramaticalmente correto.

• Análise de sentimento: é uma forma de classificação que identifica o sentimento do texto. O sentimento é transformado em um rótulo aplicado ao texto. Por exemplo, o sentimento do texto pode ser polaridades positivas ou negativas, sentimentos de raiva ou felicidade.

• Extração de entidade: extraia uma informação do texto. Por exemplo, é possível extrair o nome de um filme do texto de um artigo.

Para saber mais sobre como criar comandos de texto, consulte Criar comandos de texto (link em inglês).

Solicitação HTTP

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

Consulte o método predict para mais informações.

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, text-bison.

Para usar uma versão de modelo estável, especifique o número da versão de modelo, por exemplo, text-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 text-bison	Data da versão	Data de desativação
text-bison@002	6 de dezembro de 2023	9 de Abril de 2025

modelo de texto-unicórnio	Data da versão	Data de desativação
text-unicorn@001	30 de novembro de 2023	9 de Abril de 2025

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

Corpo da solicitação

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

Use os parâmetros a seguir para o modelo do texto text-bison. Para mais informações, consulte Criar comandos de texto.

Parâmetro	Descrição	Valores aceitáveis
prompt	Entrada de texto para gerar uma resposta do modelo. As solicitações podem incluir preâmbulos, perguntas, sugestões, instruções ou exemplos.	Texto
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 para text-bison (mais recente) 1–1024 para text-bison@002 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
stopSequence	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_number_or_id}/locations/global/collections/{collection_name}/dataStores/{DATA_STORE_ID}
candidateCount	O número de variações de resposta a serem retornadas. Para cada solicitação, você paga pelos tokens de saída de todos os candidatos, mas são cobrados apenas uma vez pelos tokens de entrada. Especificar vários candidatos é um recurso em fase de pré-lançamento que funciona com generateContent (streamGenerateContent não é compatível). Os seguintes modelos são compatíveis: Gemini 1.5 Flash: 1-8, padrão: 1 Gemini 1.5 Pro: 1-8, padrão: 1 Gemini 1.0 Pro: 1-8, padrão: 1	1–4 Default: 1
logprobs	Retorna as probabilidades de registro dos principais tokens candidatos em cada etapa de geração. Os tokens escolhidos e as probabilidades de registro do modelo são sempre retornados em cada etapa, o que pode não aparecer na lista de principais candidatos. Especifique o número de candidatos a serem retornados usando um valor inteiro no intervalo de 1 a 5.	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
echo	Se verdadeiro, o comando será repetido no texto gerado.	Optional
seed	Quando a semente é fixada em um valor específico, o modelo se esforça para fornecer a mesma resposta para solicitações repetidas. A saída determinista não é garantida. Além disso, mudar as configurações do modelo ou do parâmetro, como a temperatura, pode causar variações na resposta, mesmo quando você usa o mesmo valor de semente. Por padrão, um valor de semente aleatório é usado. Este é um recurso em fase de pré-lançamento.	Optional

Exemplo de solicitação

REST

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

Método HTTP e URL:

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

Corpo JSON da solicitação:

{
  "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 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/text-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/text-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.

import vertexai

from vertexai.language_models import TextGenerationModel

# TODO(developer): Update project_id and location
vertexai.init(project=PROJECT_ID, location="us-central1")
parameters = {
    "temperature": 0.2,  # 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}")

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): Update these variables before running the sample.
 */
const PROJECT_ID = process.env.CAIP_PROJECT_ID;
const LOCATION = 'us-central1';
const PUBLISHER = 'google';
const MODEL = 'text-bison@001';
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',
};

// Instantiates a client
const predictionServiceClient = new PredictionServiceClient(clientOptions);

async function callPredict() {
  // Configure the parent resource
  const endpoint = `projects/${PROJECT_ID}/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 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.v1.EndpointName;
import com.google.cloud.aiplatform.v1.PredictResponse;
import com.google.cloud.aiplatform.v1.PredictionServiceClient;
import com.google.cloud.aiplatform.v1.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);
    }
  }
}

Corpo da resposta

{
  "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 resposta	Descrição
content	O resultado gerado a partir do texto de entrada.
categories	Os nomes de exibição das categorias de atributo de segurança associadas ao conteúdo gerado. A ordem corresponde às pontuações.
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.
errors	Um código de erro que identifica por que a entrada ou saída foi bloqueada. Veja uma lista de códigos de erro em Filtros e atributos de segurança.
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.
input_token_count	Número de tokens de entrada. Esse é o número total de tokens em todos os comandos, os prefixos e os sufixos.
output_token_count	Número de tokens de saída. Esse é o número total de tokens em content em todas as previsões.
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
      },
      "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
        }
      }
    }
  ]
}

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.

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