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

Esta página mostra os parâmetros de amostragem opcionais que podem ser definidos em uma solicitação para um modelo. Os parâmetros disponíveis para cada modelo podem variar. Para mais informações, consulte a documentação de referência.

Parâmetros de amostragem de token

Os parâmetros nesta seção influenciam a forma como o modelo seleciona o próximo token do vocabulário. Ao ajustar esses parâmetros, você controla a aleatoriedade e a diversidade do texto gerado.

Top-P

O Top-P muda a forma como o modelo seleciona tokens para saída. Os tokens são selecionados do mais provável 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.

Para mais informações, consulte topP.

Temperatura

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. Se o modelo entrar em geração infinita, aumentar a temperatura para pelo menos 0.1 poderá levar a resultados melhores.

1.0 é o valor inicial recomendado para a temperatura.

Temperaturas mais baixas levam a resultados previsíveis (mas não completamente deterministas) resultados. Para mais informações, consulte temperature.

Parâmetros de parada

Os parâmetros nesta seção permitem controlar com precisão o comprimento e o conteúdo da saída gerada do modelo, definindo condições em que o processo de geração deve ser interrompido.

Máximo de tokens de saída

Defina maxOutputTokens para limitar o número de tokens gerados na resposta. Um token tem cerca de quatro caracteres, então 100 tokens correspondem a cerca de 60 a 80 palavras. Defina um valor baixo para limitar o comprimento da resposta.

Sequências de paradas

Defina strings em stopSequences para instruir 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 será truncada quando a string for encontrada pela primeira vez. As strings diferenciam maiúsculas de minúsculas.

Parâmetros de penalização de token

Os parâmetros nesta seção permitem controlar a probabilidade de tokens serem gerados com base na frequência e presença deles na saída.

Penalidade de frequência

Valores positivos penalizam 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é 2.0, mas não inclui. Para mais informações, consulte frequencyPenalty.

Penalidade de presença

Valores positivos penalizam 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. Para mais informações, consulte presencePenalty.

Parâmetros avançados

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

Semente

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. Para mais informações, consulte seed.

Exemplo

Confira um exemplo que usa parâmetros para ajustar a resposta de um modelo.

Python

Instalar

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 da IA generativa com a 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_ENTERPRISE=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 da IA generativa com a 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_ENTERPRISE=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://pkg.go.dev/google.golang.org/genai#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

Instalar

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 da IA generativa com a 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_ENTERPRISE=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 da IA generativa com a 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_ENTERPRISE=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();
    }
  }
}

A seguir