Se usó la API de Cloud Translation para traducir esta página.

Generación de código

Codey for Code Generation (code-bison) es el nombre del modelo que admite la generación de código.h Es un modelo de base que genera código en función de una descripción en lenguaje natural. El tipo de contenido que Codey for Code Generation puede crear incluye funciones, páginas web y pruebas de unidades. Codey for Code Generation es compatible con las APIs de generación de código. Las APIs de Codey están en la familia de APIs de PaLM.

Para explorar este modelo en la consola, consulta la tarjeta del modelo de Codey para la generación de códigos en el Model Garden.
Ir a Model Garden

Casos de uso

Estos son algunos casos de uso comunes para la generación de código:

Pruebas de unidades: Usa el mensaje para solicitar una prueba de unidades de una función.
Escribir una función: Pasa un problema al modelo para obtener una función que resuelva ese problema.
Crea una clase: Usa un mensaje para describir el propósito de una clase y tener un código que defina la clase que se muestra.

Solicitud HTTP

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

Versiones del modelo

Para usar la versión más reciente del modelo, especifica el nombre del modelo sin un número de versión, por ejemplo code-bison.

Para usar una versión del modelo estable, especifica el número de versión del modelo, por ejemplo, code-bison@002. Cada versión estable está disponible durante seis meses después de la fecha de lanzamiento de la versión estable posterior.

La siguiente tabla contiene las versiones disponibles del modelo estable:

modelo de code-bison	Fecha de lanzamiento	Fecha de descontinuación
code-bison@002	6 de diciembre de 2023	9 de abril de 2025

Para obtener más información, consulta Versiones de modelo y ciclo de vida

Cuerpo de la solicitud

{
  "instances": [
    { "prefix": string }
  ],
  "parameters": {
    "temperature": number,
    "maxOutputTokens": integer,
    "candidateCount": integer,
    "stopSequences": [ string ]
    "logprobs": integer,
    "presencePenalty": float,
    "frequencyPenalty": float,
    "echo": boolean,
    "seed": integer
  }
}

Los siguientes son los parámetros para el modelo de generación de código llamado code-bison. El modelo code-bison es uno de los modelos en Codey. Puedes usar estos parámetros para optimizar el mensaje de finalización de código. Para obtener más información, consulta Descripción general de los modelos de código y Crear mensajes para completar el código.

Parámetro	Descripción	Valores aceptables
`prefix` (obligatorio)	Para los modelos de código, `prefix` representa el comienzo de un fragmento de código significativo o una solicitud de lenguaje natural que describe el código que se generará.	Una cadena de texto válida
`temperature`	La temperatura se usa para realizar muestreos durante la generación de respuesta. 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 creativa, mientras que las temperaturas más altas pueden generar resultados más diversos o creativos. Una temperatura de `0` significa que siempre se eligen 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.	`0.0–1.0` `Default: 0.2`
`maxOutputTokens`	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.	`1–2048` `Default: 1024`
`candidateCount` (opcional)	La cantidad de variaciones de respuesta que se mostrarán. Por cada solicitud, se te cobra por los tokens de salida de todos los candidatos, pero solo se te cobra una vez por los tokens de entrada. Especificar varios candidatos es una función de vista previa que funciona con `generateContent` (no se admite `streamGenerateContent`). Se admiten los siguientes modelos: Gemini 1.5 Flash: `1`-`8`, predeterminado: `1` Gemini 1.5 Pro: `1`-`8`, predeterminado: `1` Gemini 1.0 Pro: `1`-`8`, predeterminado: `1`	`1-4` `Default: 1`
`stopSequences` (opcional)	Especifica una lista de cadenas que le indica al modelo que deje de generar texto si se encuentra una de las cadenas en la respuesta. Si una cadena aparece varias veces en la respuesta, la respuesta trunca el lugar en que se encontró por primera vez. Las cadenas distinguen entre mayúsculas y minúsculas. Por ejemplo, si la siguiente es la respuesta que se muestra cuando no se especifica `stopSequences`: `public static string reverse(string myString)` Luego, la respuesta que se muestra con `stopSequences` configurada como `["Str", "reverse"]` es la siguiente: `public static string`	Una lista de cadenas
`logprobs` (opcional)	Devuelve las probabilidades de registro de los tokens candidatos principales en cada paso de generación. Es posible que el token elegido del modelo no sea el mismo que el token de candidato principal en cada paso. Especifica la cantidad de candidatos que se mostrarán con un valor de número entero en el rango de `1` a `5`.	`0-5`
`frequencyPenalty` (opcional)	Los valores positivos penalizan los tokens que aparecen repetidamente en el texto generado, lo que disminuye la probabilidad de repetir contenido. El valor mínimo es `-2.0`. El valor máximo es hasta `2.0`, pero no lo incluye.	`Minimum value: -2.0 Maximum value: 2.0`
`presencePenalty` (opcional)	Los valores positivos penalizan los tokens que ya aparecen en el texto generado, lo que aumenta la probabilidad de generar contenido más diverso. El valor mínimo es `-2.0`. El valor máximo es hasta `2.0`, pero no lo incluye.	`Minimum value: -2.0 Maximum value: 2.0`
`echo` (opcional)	Si es verdadero, el mensaje se repite en el texto generado.	`Optional`
`seed`	Cuando el valor semilla se fija en un valor específico, el modelo hace su mejor esfuerzo para proporcionar la misma respuesta para las solicitudes repetidas. No se garantiza un resultado determinístico. Además, cambiar la configuración del modelo o del parámetro, como la temperatura, puede causar variaciones en la respuesta, incluso cuando usas el mismo valor semilla. Según la configuración predeterminada, se usa un valor semilla aleatorio. Esta es una función de versión preliminar.	`Optional`

Solicitud de muestra

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.

Cuerpo de la solicitud

Método HTTP y URL:

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

Cuerpo JSON de la solicitud:

{
  "instances": [
    { "prefix": "PREFIX" }
  ],
  "parameters": {
    "temperature": TEMPERATURE,
    "maxOutputTokens": MAX_OUTPUT_TOKENS,
    "candidateCount": CANDIDATE_COUNT
  }
}

Para enviar tu solicitud, elige una de estas opciones:

curl

Nota: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login, o a través del uso de Cloud Shell, que accede de forma automática a la CLI de gcloud. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

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

PowerShell

Nota: En el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login . Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

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/code-bison:predict" | Select-Object -Expand Content

Deberías recibir una respuesta JSON similar a la respuesta de ejemplo.

Python

Si deseas obtener información para instalar o actualizar el SDK de Vertex AI para 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 CodeGenerationModel

parameters = {
    "temperature": 0.1,  # Temperature controls the degree of randomness in token selection.
    "max_output_tokens": 256,  # Token limit determines the maximum amount of text output.
}

code_generation_model = CodeGenerationModel.from_pretrained("code-bison@001")
response = code_generation_model.predict(
    prefix="Write a function that checks if a year is a leap year.", **parameters
)

print(f"Response from Model: {response.text}")
# Example response:
# Response from Model: I will write a function to check if a year is a leap year.
# **The function will take a year as input and return a boolean value**.
# **The function will first check if the year is divisible by 4.**
# ...

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 = 'code-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 = {
    prefix: 'Write a function that checks if a year is a leap year.',
  };
  const instanceValue = helpers.toValue(prompt);
  const instances = [instanceValue];

  const parameter = {
    temperature: 0.5,
    maxOutputTokens: 256,
  };
  const parameters = helpers.toValue(parameter);

  const request = {
    endpoint,
    instances,
    parameters,
  };

  // Predict request
  const [response] = await predictionServiceClient.predict(request);
  console.log('Get code generation 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.


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.InvalidProtocolBufferException;
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 PredictCodeGenerationFunctionSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace this variable before running the sample.
    String project = "YOUR_PROJECT_ID";

    // Learn how to create prompts to work with a code model to generate code:
    // https://cloud.google.com/vertex-ai/docs/generative-ai/code/code-generation-prompts
    String instance = "{ \"prefix\": \"Write a function that checks if a year is a leap year.\"}";
    String parameters = "{\n" + "  \"temperature\": 0.5,\n" + "  \"maxOutputTokens\": 256,\n" + "}";
    String location = "us-central1";
    String publisher = "google";
    String model = "code-bison@001";

    predictFunction(instance, parameters, project, location, publisher, model);
  }

  // Use Codey for Code Generation to generate a code function
  public static void predictFunction(
      String instance,
      String parameters,
      String project,
      String location,
      String publisher,
      String model)
      throws IOException {
    final 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);

      Value instanceValue = stringToValue(instance);
      List<Value> instances = new ArrayList<>();
      instances.add(instanceValue);

      Value parameterValue = stringToValue(parameters);

      PredictResponse predictResponse =
          predictionServiceClient.predict(endpointName, instances, parameterValue);
      System.out.println("Predict Response");
      System.out.println(predictResponse);
    }
  }

  // Convert a Json string to a protobuf.Value
  static Value stringToValue(String value) throws InvalidProtocolBufferException {
    Value.Builder builder = Value.newBuilder();
    JsonFormat.parser().merge(value, builder);
    return builder.build();
  }
}

Cuerpo de la respuesta

{
  "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": false,
        "scores": [ float ],
        "errors": [ int ]
      },
      "score": float
    }
  ]
}

Elemento de la respuesta	Descripción
`blocked`	Una marca `boolean` asociada con un atributo de seguridad que indica si la entrada o salida del modelo se bloqueó. Si `blocked` es `true`, el campo `errors` en la respuesta contiene uno o más códigos de error. Si `blocked` es `false`, la respuesta no incluye el campo `errors`.
`categories`	Enumerar los nombres de las categorías de atributos de seguridad que están asociados con el contenido generado. El orden de las puntuaciones en el parámetro `scores` coincide con el orden de las categorías. Por ejemplo, la primera puntuación en el parámetro `scores` indica la probabilidad de que la respuesta infrinja la primera categoría en la lista `categories`.
`citationMetadata`	Un elemento que contiene un array de citas.
`citations`	Un array de citas. Cada cita contiene sus metadatos.
`content`	El resultado que genera el modelo con el texto de entrada.
`endIndex`	Un número entero que especifica dónde termina una cita en `content`.
`errors`	Un array de códigos de error. El campo de respuesta `errors` se incluye en la respuesta solo cuando el campo `blocked` en la respuesta es `true`. Para obtener más información sobre los códigos de error, consulta Errores de seguridad.
`license`	Es la licencia asociada con una cita.
`publicationDate`	La fecha en que se publicó una cita. Sus formatos válidos son `YYYY`, `YYYY-MM` y `YYYY-MM-DD`.
`safetyAttributes`	Un array de atributos de seguridad. El array contiene un atributo de seguridad para cada candidato de respuesta.
`score`	Un valor `float` menor que cero. Cuanto más alto sea el valor de `score`, mayor será la confianza del modelo en su respuesta.
`startIndex`	Un número entero que especifica dónde comienza una cita en el `content`.
`title`	Es el título de una fuente de cita. Los ejemplos de títulos de origen pueden ser los de un artículo de noticias o un libro.
`url`	Es la URL de una fuente de cita. Los ejemplos de una fuente de URL pueden ser un sitio web de noticias o un repositorio de GitHub.
`tokens`	Los tokens de muestra.
`tokenLogProbs`	Las probabilidades de registro de los tokens de muestra.
`topLogProbs`	Los tokens de candidatos más probables y sus probabilidades de registro en cada paso.
`logprobs`	Resultados del parámetro “logprobs”. Asignación de 1 a 1 a “candidatos”.

Respuesta de muestra

{
  "predictions":[
    {
      "citationMetadata": {
        "citations": [ ]
      },
      "safetyAttributes": {
        "scores": [ ],
        "categories": [ ],
        "blocked": false
      },
      "content": "CONTENT",
      "score": -1.1161688566207886
    }
  ]
}

Respuesta de transmisión desde modelos de IA generativa

Los parámetros son los mismos para las solicitudes de transmisión y las de no transmisión a las APIs.

Para ver solicitudes de código y respuestas de muestra con la API de REST, consulta Ejemplos que usan la API de REST de transmisión.

Si deseas ver las solicitudes de código y las respuestas de muestra con el SDK de Vertex AI para Python, consulta Ejemplos que usan el SDK de Vertex AI para Python para la transmisión.