Parâmetros de geração de conteúdo

Esta página mostra os parâmetros de amostragem opcionais que pode definir num pedido a um modelo. Os parâmetros disponíveis para cada modelo podem diferir. Para mais informações, consulte a documentação de referência.

Parâmetros de amostragem de tokens

Top-P

O Top-P altera a forma como o modelo seleciona tokens para a saída. Os tokens são selecionados do mais provável para o menos provável até que a soma das respetivas probabilidades seja igual ao valor de 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 seleciona A ou B como o token seguinte através da temperatura e exclui C como um candidato.

Especifique um valor inferior para respostas menos aleatórias e um valor superior para respostas mais aleatórias.

Para mais informações, consulte topP.

Temperatura

A temperatura é usada para a amostragem durante a geração de respostas, que ocorre quando topP e topK são aplicados. A temperatura controla o grau de aleatoriedade na seleção de tokens. As temperaturas mais baixas são adequadas para comandos que requerem uma resposta menos aberta ou criativa, enquanto as temperaturas mais altas podem gerar resultados mais diversos ou criativos. Uma temperatura de 0 significa que os tokens de probabilidade mais elevada são sempre selecionados. Neste caso, as respostas para um determinado comando são maioritariamente determinísticas, mas ainda é possível uma pequena variação.

Se o modelo devolver uma resposta demasiado genérica, demasiado curta ou uma resposta alternativa, experimente aumentar a temperatura.

As temperaturas mais baixas geram resultados previsíveis (mas não completamente determinísticos). Para mais informações, consulte temperature.

Parâmetros de paragem

Número máximo de tokens de saída

Defina maxOutputTokens para limitar o número de tokens gerados na resposta. Um token tem aproximadamente quatro carateres, pelo que 100 tokens correspondem a cerca de 60 a 80 palavras. Defina um valor baixo para limitar a duração da resposta.

Sequências de paragem

Defina strings em stopSequences para indicar ao modelo que pare de gerar texto se uma das strings for encontrada na resposta. Se uma string aparecer várias vezes na resposta, a resposta é truncada no ponto em que a string é encontrada pela primeira vez. As strings são sensíveis a maiúsculas e minúsculas.

Parâmetros de penalização de tokens

Penalização de frequência

Os valores positivos penalizam os tokens que aparecem repetidamente no texto gerado, diminuindo a probabilidade de repetir conteúdo. O valor mínimo é -2.0. O valor máximo é até, mas não incluindo, 2.0. Para mais informações, consulte frequencyPenalty.

Penalização por presença

Os valores positivos penalizam os tokens que já aparecem no texto gerado, aumentando a probabilidade de gerar conteúdo mais diversificado. O valor mínimo é -2.0. O valor máximo é até 2.0, mas não inclui este valor. Para mais informações, consulte presencePenalty.

Parâmetros avançados

Use estes parâmetros para devolver mais informações sobre os tokens na resposta ou para controlar a variabilidade da resposta.

Probabilidades de registo de tokens de saída

Devolve as probabilidades de registo dos tokens candidatos principais em cada passo de geração. O token escolhido pelo modelo pode não ser o mesmo que o token candidato principal em cada passo. Especifique o número de candidatos a devolver usando um valor inteiro no intervalo de 1-20. Para mais informações, consulte logprobs. Também tem de definir o parâmetro responseLogprobs como true para usar esta funcionalidade.

O parâmetro responseLogprobs devolve as probabilidades logarítmicas dos tokens escolhidos pelo modelo em cada passo.

Para mais informações, consulte o bloco de notas Introdução ao Logprobs.

Número aleatório

Quando a semente é fixada num valor específico, o modelo faz o seu melhor para fornecer a mesma resposta para pedidos repetidos. O resultado determinístico não é garantido. Além disso, a alteração das definições do modelo ou dos parâmetros, como a temperatura, pode provocar variações na resposta, mesmo quando usa o mesmo valor de semente. Por predefinição, é usado um valor de semente aleatório. Para mais informações, consulte seed.

Exemplo

Segue-se um exemplo que usa parâmetros para ajustar a resposta de um modelo.

Python

Instalação

pip install --upgrade google-genai

Para saber mais, consulte a documentação de referência do SDK.

Defina variáveis de ambiente para usar o SDK de IA generativa com o Vertex AI: 

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_VERTEXAI=True
 

from google import genai
from google.genai.types import GenerateContentConfig, HttpOptions

client = genai.Client(http_options=HttpOptions(api_version="v1"))
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Why is the sky blue?",
    # See the SDK documentation at
    # https://googleapis.github.io/python-genai/genai.html#genai.types.GenerateContentConfig
    config=GenerateContentConfig(
        temperature=0,
        candidate_count=1,
        response_mime_type="application/json",
        top_p=0.95,
        top_k=20,
        seed=5,
        max_output_tokens=500,
        stop_sequences=["STOP!"],
        presence_penalty=0.0,
        frequency_penalty=0.0,
    ),
)
print(response.text)
# Example response:
# {
#   "explanation": "The sky appears blue due to a phenomenon called Rayleigh scattering. When ...
# }

Go

Saiba como instalar ou atualizar o Go.

Para saber mais, consulte a documentação de referência do SDK.

Defina variáveis de ambiente para usar o SDK de IA generativa com o Vertex AI: 

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_VERTEXAI=True
 

import (
	"context"
	"fmt"
	"io"

	genai "google.golang.org/genai"
)

// generateWithConfig shows how to generate text using a text prompt and custom configuration.
func generateWithConfig(w io.Writer) error {
	ctx := context.Background()

	client, err := genai.NewClient(ctx, &genai.ClientConfig{
		HTTPOptions: genai.HTTPOptions{APIVersion: "v1"},
	})
	if err != nil {
		return fmt.Errorf("failed to create genai client: %w", err)
	}

	modelName := "gemini-2.5-flash"
	contents := genai.Text("Why is the sky blue?")
	// See the documentation: https://googleapis.github.io/python-genai/genai.html#genai.types.GenerateContentConfig
	config := &genai.GenerateContentConfig{
		Temperature:      genai.Ptr(float32(0.0)),
		CandidateCount:   int32(1),
		ResponseMIMEType: "application/json",
	}

	resp, err := client.Models.GenerateContent(ctx, modelName, contents, config)
	if err != nil {
		return fmt.Errorf("failed to generate content: %w", err)
	}

	respText := resp.Text()

	fmt.Fprintln(w, respText)
	// Example response:
	// {
	//   "explanation": "The sky is blue due to a phenomenon called Rayleigh scattering ...
	// }

	return nil
}

Node.js

Instalação

npm install @google/genai

Para saber mais, consulte a documentação de referência do SDK.

Defina variáveis de ambiente para usar o SDK de IA generativa com o Vertex AI: 

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_VERTEXAI=True
 

const {GoogleGenAI} = require('@google/genai');

const GOOGLE_CLOUD_PROJECT = process.env.GOOGLE_CLOUD_PROJECT;
const GOOGLE_CLOUD_LOCATION = process.env.GOOGLE_CLOUD_LOCATION || 'global';

async function generateContent(
  projectId = GOOGLE_CLOUD_PROJECT,
  location = GOOGLE_CLOUD_LOCATION
) {
  const client = new GoogleGenAI({
    vertexai: true,
    project: projectId,
    location: location,
  });

  const config = {
    temperature: 0,
    candidateCount: 1,
    responseMimeType: 'application/json',
    topP: 0.95,
    topK: 20,
    seed: 5,
    maxOutputTokens: 500,
    stopSequences: ['STOP!'],
    presencePenalty: 0.0,
    frequencyPenalty: 0.0,
  };

  const response = await client.models.generateContent({
    model: 'gemini-2.5-flash',
    contents: 'Why is the sky blue?',
    config: config,
  });

  console.log(response.text);

  // Example response:
  // {
  //   "explanation": "The sky appears blue due to a phenomenon called Rayleigh scattering. When ...
  // }

  return response.text;
}

Java

Saiba como instalar ou atualizar o Java.

Para saber mais, consulte a documentação de referência do SDK.

Defina variáveis de ambiente para usar o SDK de IA generativa com o Vertex AI: 

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_VERTEXAI=True
 


import com.google.genai.Client;
import com.google.genai.types.GenerateContentConfig;
import com.google.genai.types.GenerateContentResponse;
import com.google.genai.types.HttpOptions;

public class TextGenerationConfigWithText {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String modelId = "gemini-2.5-flash";
    generateContent(modelId);
  }

  // Generates text with text input and optional configurations
  public static String generateContent(String modelId) {
    // Client Initialization. Once created, it can be reused for multiple requests.
    try (Client client =
        Client.builder()
            .location("global")
            .vertexAI(true)
            .httpOptions(HttpOptions.builder().apiVersion("v1").build())
            .build()) {

      // Set optional configuration parameters
      GenerateContentConfig contentConfig =
          GenerateContentConfig.builder()
              .temperature(0.0F)
              .candidateCount(1)
              .responseMimeType("application/json")
              .topP(0.95F)
              .topK(20F)
              .seed(5)
              .maxOutputTokens(500)
              .stopSequences("STOP!")
              .presencePenalty(0.0F)
              .frequencyPenalty(0.0F)
              .build();

      // Generate content using optional configuration
      GenerateContentResponse response =
          client.models.generateContent(modelId, "Why is the sky blue?", contentConfig);

      System.out.print(response.text());
      // Example response:
      // {
      //  "explanation": "The sky appears blue due to a phenomenon called Rayleigh scattering.
      // Sunlight, which appears white, is actually composed of all the colors of the rainbow...
      // }
      return response.text();
    }
  }
}

O que se segue?