Finalización de código

Codey para la finalización de código (code-gecko) es el nombre del modelo que admite la finalización de código. Es un modelo de base que genera código en función de lo que se escribe en código. Codey para la finalización de código completa el código que un usuario escribió hace poco. Codey para la finalización de código es compatible con la API de generación de código. Las APIs de Codey están en la familia de APIs de PaLM.

Si deseas obtener más información sobre cómo crear mensajes para completar el código, consulta Crea instrucciones para completar el código.

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

Casos de uso

Estos son algunos casos de uso comunes de finalización de código:

Escribe código más rápido: usa el modelo code-gecko para escribir código más rápido; para ello, aprovecha el código que se te sugirió.
Minimiza errores en el código: Usa las sugerencias de código que sabes que son correctas en términos sintácticos para evitar errores. La finalización de código te ayuda a minimizar el riesgo de ingresar errores de forma accidental que puedan ocurrir cuando escribes código con rapidez.

Solicitud HTTP

POST https://us-central1-googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/code-gecko: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-gecko.

Para usar una versión del modelo estable, especifica el número de versión del modelo, por ejemplo, code-gecko@001. 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-gecko	Fecha de lanzamiento	Fecha de descontinuación
code-gecko@002	6 de diciembre de 2023	9 de octubre de 2024
code-gecko@001	29 de junio de 2023	6 julio de 2024

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

Cuerpo de la solicitud

{
  "instances":[
    {
      "prefix": string,
      "suffix": 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 finalización de código llamado code-gecko. El modelo code-gecko es uno de los modelos de 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á. El modelo intenta completar el código entre `prefix` y `suffix`.	Una cadena de texto válida
`suffix` (opcional)	Para completar el código, `suffix` representa el final de un fragmento de programación significativo. El modelo intenta completar el código entre `prefix` y `suffix`.	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-64` `Default: 64`
`candidateCount` (opcional)	La cantidad de variaciones de respuesta que se mostrarán.	`1-4` `Default: 1` (opcional)

`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 los tokens principales candidatos de `logprobs` más probables con sus probabilidades de registro en cada paso de generación. Los tokens elegidos y sus probabilidades de registro en cada paso siempre se muestran. El token elegido puede o no estar en los `logprobs` principales con más probabilidades de ser candidatos.	`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. Los valores aceptables son: `-2.0`—`2.0`	`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. Los valores aceptables son: `-2.0`—`2.0`	`Minimum value: -2.0 Maximum value: 2.0`
`echo` (opcional)	Si es verdadero, el mensaje se repite en el texto generado.	`Optional`
`seed`	El decodificador genera ruido aleatorio con un generador de números pseudoaleatorios, se agrega temperatura * ruido a los logits antes del muestreo. El generador de números pseudoaleatorios (prng) toma un valor inicial como entrada y genera el mismo resultado con el mismo valor inicial. Si no se establece el valor inicial, el valor inicial usado en el decodificador no será determinista, por lo que el ruido aleatorio generado no será determinístico. Si se establece el valor inicial, el ruido aleatorio generado será determinístico.	`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-gecko:predict

Cuerpo JSON de la solicitud:

{
  "instances": [
    { "prefix": "PREFIX",
      "suffix": "SUFFIX"}
  ],
  "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-gecko:predict"

PowerShell

Nota: El siguiente comando supone que accediste a la CLI de gcloud con tu cuenta de usuario mediante 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-gecko: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 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

def complete_code_function(temperature: float = 0.2) -> object:
    """Example of using Codey for Code Completion to complete a function."""

    # TODO developer - override these parameters as needed:
    parameters = {
        "temperature": temperature,  # Temperature controls the degree of randomness in token selection.
        "max_output_tokens": 64,  # Token limit determines the maximum amount of text output.
    }

    code_completion_model = CodeGenerationModel.from_pretrained("code-gecko@001")
    response = code_completion_model.predict(
        prefix="def reverse_string(s):", **parameters
    )

    print(f"Response from Model: {response.text}")

    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-gecko@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:
      'def reverse_string(s): \
        return s[::-1] \
      #This function',
  };
  const instanceValue = helpers.toValue(prompt);
  const instances = [instanceValue];

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

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

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

  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 create code completion suggestions:
    // https://cloud.google.com/vertex-ai/docs/generative-ai/code/code-completion-prompts
    String instance =
        "{ \"prefix\": \""
            + "def reverse_string(s):\n"
            + "  return s[::-1]\n"
            + "#This function"
            + "\"}";
    String parameters = "{\n" + "  \"temperature\": 0.2,\n" + "  \"maxOutputTokens\": 64,\n" + "}";
    String location = "us-central1";
    String publisher = "google";
    String model = "code-gecko@001";

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

  // Use Codey for Code Completion to complete a code comment
  public static void predictComment(
      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": boolean,
        "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`.
`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 contenido.
`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": [
    {
      "safetyAttributes": {
        "blocked": false,
        "categories": [],
        "scores": []
      },
      "content": " reverses a string",
      "citationMetadata": {
        "citations": []
      }
    },
    "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.