Geração de códigos

Codey para geração de código (code-bison) é o nome do modelo compatível com a geração de código. É um modelo de base que gera código com base em uma descrição da linguagem natural. O tipo de conteúdo que o Codey para geração de código pode criar inclui funções, páginas da Web e testes de unidade. O Codey para geração de código é compatível com as APIs Codey de geração de código. As APIs do Codey estão na família de APIs do PaLM.

Para explorar esse modelo no console, consulte o card de modelo Codey para geração de código no Model Garden.
<a{: class="button button-primary" l10n-attrs-original-order="href,target,class,track-name,track-type" l10n-encrypted-href="kDsq5VTi6ASK/vNFlrWmnltigmNHgUGOXn/QVSGplOi71dheYhG9dKuv3S+0ajmQkfzB9oP/Mo2x7xIe1klR5YSKTX7LV1jkkg0C2Ndofq2g0LY5rER9QL0JoE/A8FHO" target="console" track-name="consoleLink" track-type="tasks" }="">Acesse o Model Garden</a{:>

Casos de uso

Alguns casos comuns usados para gerar códigos são:

  • Testes de unidade: use o prompt para solicitar um teste de unidade para uma função.

  • Gravar uma função: transmita um problema ao modelo para ter uma função que solucione esse problema.

  • Criar uma classe: use uma solicitação para descrever a finalidade de uma classe e tenha o código que define a classe retornada.

Solicitação HTTP

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

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

Para usar uma versão de modelo estável, especifique o número da versão de modelo, por exemplo, code-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 code-bison Data da versão Data de desativação
code-bison@002 6 de dezembro de 2023 Não relevante
code-bison@001 29 de junho de 2023 6 de julho de 2024

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

Corpo da solicitação

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

Veja a seguir os parâmetros do modelo de geração de código chamado code-bison. O modelo code-bison é um dos modelos do Codey. Use esses parâmetros para otimizar o prompt de conclusão de código. Para mais informações, consulte Visão geral dos modelos de código e Criar prompts para preenchimento de código.

Parâmetro Descrição Valores aceitáveis

prefix

(obrigatório)

Para modelos de código, prefix representa o início de um código de programação significativo ou um prompt de linguagem natural que descreve o código a ser gerado. Uma string de texto válida

temperature

A temperatura é usada para amostragem durante a geração da resposta. 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 as 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, deterministas, mas uma pequena quantidade de variação ainda é possível.

0.0–1.0

Default: 0.2

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

Default: 1024

candidateCount

(opcional)

O número de variações de resposta a serem retornadas.

1-4

Default: 1

stopSequences

(opcional)

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
Uma lista de strings

logprobs

(opcional)

Retorna os principais tokens logprobs candidatos com as respectivas probabilidades de registro em cada etapa de geração. Os tokens escolhidos e as probabilidades de registro deles em cada etapa são sempre retornados. O token escolhido pode ou não estar entre os principais candidatos de logprobs.

0-5

frequencyPenalty

(opcional)

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

(opcional)

Valores positivos penalizam tokens que já aparecem no texto gerado, aumentando a probabilidade de gerar conteúdo mais diversificado. Os valores aceitáveis são: -2.0, 2.0.

Minimum value: -2.0 Maximum value: 2.0

echo

(opcional)

Se verdadeiro, o comando será repetido no texto gerado.

Optional

seed

O decodificador gera ruído aleatório com um gerador de número pseudoaleatório. O ruído de temperatura * é adicionado aos logits antes da amostragem. O gerador de número pseudoaleatório (prng) usa uma seed como entrada e gera a mesma saída com a mesma seed.

Se a seed não for definida, a seed usada no decodificador não será determinista. Portanto, o ruído aleatório gerado não será determinista. Se a seed for definida, o ruído aleatório gerado será determinista.

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 http://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/code-bison:predict

    Corpo JSON da solicitação:

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

    Para enviar a solicitação, escolha uma destas opções:

    curl

    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 \
    "http://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/code-bison:predict"

    PowerShell

    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 "http://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/code-bison:predict" | Select-Object -Expand Content

    Você receberá uma resposta JSON semelhante à amostra de resposta.

SDK da Vertex AI para Python

Para saber como instalar o SDK da Vertex AI para Python, consulte Instalar o SDK da Vertex AI para Python. Saiba mais na documentação de referência da API SDK da Vertex AI para Python.

from vertexai.language_models import CodeGenerationModel

def generate_a_function(temperature: float = 0.5) -> object:
    """Example of using Codey for Code Generation to write a function."""

    # TODO developer - override these parameters as needed:
    parameters = {
        "temperature": temperature,  # 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}")

    return response

if __name__ == "__main__":
    generate_a_function()

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): 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 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.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 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:
    // http://cloud.go888ogle.com.fqhub.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();
  }
}

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": false,
        "scores": [ float ],
        "errors": [ int ]
      },
      "score": float
    }
  ]
}
Elemento de resposta Descrição
blocked Uma flag boolean associada a um atributo de segurança que indica se a entrada ou a saída do modelo foi bloqueada. Se blocked for true, o campo errors na resposta conterá um ou mais códigos de erro. Se blocked for false, a resposta não conterá o campo errors.
categories Uma lista dos nomes das categorias de atributo de segurança associadas ao conteúdo gerado. A ordem das pontuações no parâmetro scores corresponde à ordem das categorias. Por exemplo, a primeira pontuação no parâmetro scores indica a probabilidade de a resposta violar a primeira categoria na lista categories.
citationMetadata Um elemento que contém uma matriz de citações.
citations Uma matriz de citações. Cada citação contém os metadados correspondentes.
content O resultado gerado pelo modelo usando o texto de entrada.
endIndex Um número inteiro que especifica onde uma citação termina em content.
errors Uma matriz de códigos de erro. O campo de resposta errors está incluso na resposta somente quando o campo blocked nela é true. Para saber mais sobre como entender códigos de erro, consulte Erros de segurança.
license A licença associada a uma citação.
publicationDate A data em que uma citação foi publicada. Os formatos válidos são YYYY, YYYY-MM e YYYY-MM-DD.
safetyAttributes Uma matriz de atributos de segurança. A matriz contém um atributo de segurança para cada candidato a resposta.
score Um valor float menor que zero. Quanto maior o valor de score, maior a confiança do modelo na resposta.
startIndex Um número inteiro que especifica onde começa uma citação no conteúdo.
title O título de uma fonte de citação. Alguns exemplos de títulos de fontes são os de artigos de notícias ou livros.
url O URL de uma fonte de citação. Exemplos de uma fonte de URL podem ser um site de notícias ou um repositório do GitHub.
tokens Os tokens de amostra.
tokenLogProbs Probabilidades de registro dos tokens de amostra.
topLogProbs 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": [ ],
        "categories": [ ],
        "blocked": false
      },
      "content": "CONTENT",
      "score": -1.1161688566207886
    }
  ]
}

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 de streaming.

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