Questa pagina è stata tradotta dall'API Cloud Translation.

Generazione del codice

Codey per la generazione di codice (code-bison) è il nome del modello che supporta la generazione di codice. È un modello di base che genera codice in base a una descrizione in linguaggio naturale. Il tipo di contenuti che Codey per la generazione di codice può creare include funzioni, pagine web e test delle unità. Codey per la generazione del codice è supportato dalle API Codey per la generazione del codice. Le API Codey fanno parte della famiglia di API PaLM.

Per esplorare questo modello nella console, consulta la scheda del modello Codey per la generazione di codice in Model Garden.
Vai a Model Garden

Casi d'uso

Ecco alcuni casi d'uso comuni per la generazione di codice:

Test delle unità: utilizza il prompt per richiedere un test delle unità per una funzione.
Scrivere una funzione: passa un problema al modello per ottenere una funzione che lo risolva.
Crea una classe: utilizza un prompt per descrivere lo scopo di una classe e avere il codice che definisce la classe restituita.

Richiesta HTTP

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

Versioni modello

Per utilizzare la versione più recente del modello, specifica il nome del modello senza un numero di versione, ad esempio code-bison.

Per utilizzare una versione stabile del modello, specifica il numero di versione del modello, ad esempio code-bison@002. Ogni versione stabile è disponibile per sei mesi dopo la data di rilascio della versione stabile successiva.

La tabella seguente contiene le versioni stabili del modello disponibili:

modello code-bison	Data di uscita	Data di ritiro
code-bison@002	6 dicembre 2023	9 aprile 2025

Per ulteriori informazioni, consulta Versioni e ciclo di vita dei modelli.

Corpo della richiesta

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

Di seguito sono riportati i parametri per il modello di generazione di codice denominato code-bison. Il modello code-bison è uno dei modelli di Codey. Puoi utilizzare questi parametri per ottimizzare la richiesta di completamento del codice. Per ulteriori informazioni, consulta la Panoramica dei modelli di codice e Creare prompt per il completamento del codice.

Parametro	Descrizione	Valori accettati
`prefix` (obbligatorio)	Per i modelli di codice, `prefix` rappresenta l'inizio di un codice di programmazione significativo o un prompt in linguaggio naturale che descrive il codice da generare.	Una stringa di testo valida
`temperature`	La temperatura viene utilizzata per il campionamento durante la generazione della risposta. La temperatura controlla il grado di randomicità nella selezione dei token. Le temperature più basse sono ideali per prompt che richiedono risposte meno creative o aperte, mentre le temperature più alte possono portare a risultati più diversificati o creativi. Con una temperatura pari a `0`, vengono sempre selezionati i token con la probabilità più alta. In questo caso, le risposte per un determinato prompt sono per lo più deterministiche, ma è ancora possibile una piccola variazione.	`0.0–1.0` `Default: 0.2`
`maxOutputTokens`	Numero massimo di token che possono essere generati nella risposta. Un token equivale a circa quattro caratteri. 100 token corrispondono a circa 60-80 parole. Specifica un valore più basso per risposte più brevi e un valore più alto per risposte potenzialmente più lunghe.	`1–2048` `Default: 1024`
`candidateCount` (facoltativo)	Il numero di varianti di risposta da restituire. Per ogni richiesta, ti vengono addebitati i token di output di tutti i candidati, ma solo una volta per i token di input. La specifica di più candidati è una funzionalità di anteprima che funziona con `generateContent` (`streamGenerateContent` non è supportato). Sono supportati i seguenti modelli: Gemini 1.5 Flash: `1`-`8`, valore predefinito: `1` Gemini 1.5 Pro: `1`-`8`, valore predefinito: `1` Gemini 1.0 Pro: `1`-`8`, valore predefinito: `1`	`1-4` `Default: 1`
`stopSequences` (facoltativo)	Specifica un elenco di stringhe che indica al modello di interrompere la generazione di testo se viene rilevata una delle stringhe nella risposta. Se una stringa viene visualizzata più volte nella risposta, la risposta viene troncata nel punto in cui viene rilevata per la prima volta. Le stringhe sono sensibili alle maiuscole. Ad esempio, se la seguente è la risposta restituita quando `stopSequences` non è specificato: `public static string reverse(string myString)` La risposta restituita con `stopSequences` impostato su `["Str", "reverse"]` è: `public static string`	Un elenco di stringhe
`logprobs` (facoltativo)	Restituisce le probabilità logaritmiche dei token candidati principali in ogni fase di generazione. Il token scelto dal modello potrebbe non essere uguale al token candidato principale in ogni passaggio. Specifica il numero di candidati da restituire utilizzando un valore intero nell'intervallo `1`-`5`.	`0-5`
`frequencyPenalty` (facoltativo)	I valori positivi penalizzano i token che appaiono ripetutamente nel testo generato, diminuendo la probabilità di ripetere i contenuti. Il valore minimo è `-2.0`. Il valore massimo è fino a, ma non incluso, `2.0`.	`Minimum value: -2.0 Maximum value: 2.0`
`presencePenalty` (facoltativo)	I valori positivi penalizzano i token già presenti nel testo generato, aumentando la probabilità di generare contenuti più diversi. Il valore minimo è `-2.0`. Il valore massimo può arrivare fino a `2.0`, escluso.	`Minimum value: -2.0 Maximum value: 2.0`
`echo` (facoltativo)	Se il valore è true, il prompt viene ripetuto nel testo generato.	`Optional`
`seed`	Quando il seed è fissato a un valore specifico, il modello fa del suo meglio per fornire la stessa risposta per richieste ripetute. L'output deterministico non è garantito. Inoltre, la modifica del modello o delle impostazioni dei parametri, ad esempio la temperatura, può causare variazioni nella risposta anche se utilizzi lo stesso valore seed. Per impostazione predefinita, viene utilizzato un valore seed casuale. Questa è una funzionalità in anteprima.	`Optional`

Richiesta di esempio

REST

Per testare un prompt di testo utilizzando l'API Vertex AI, invia una richiesta POST all'endpoint del modello del publisher.

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

PROJECT_ID: il tuo ID progetto.

Testo della richiesta

Metodo HTTP e URL:

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

Corpo JSON della richiesta:

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

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Nota: il seguente comando presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti consente di accedere automaticamente all'interfaccia a riga di comando gcloud. Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente:

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: il comando seguente presuppone che tu abbia eseguito l'accesso alla CLI gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente:

$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

Dovresti ricevere una risposta JSON simile alla risposta di esempio.

Python

Per scoprire come installare o aggiornare l'SDK Vertex AI per Python, consulta Installare l'SDK Vertex AI per Python. Per saperne di più, consulta la documentazione di riferimento dell'API 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

Prima di provare questo esempio, segui le istruzioni di configurazione Node.js riportate nella guida rapida all'utilizzo delle librerie client di Vertex AI. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Node.js di Vertex AI.

Per autenticarti in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

/**
 * 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

Prima di provare questo esempio, segui le istruzioni di configurazione Java riportate nella guida rapida all'utilizzo delle librerie client di Vertex AI. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Java di Vertex AI.

Per autenticarti in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.


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();
  }
}

Corpo della risposta

{
  "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 Response	Descrizione
`blocked`	Un flag `boolean` associato a un attributo di sicurezza che indica se l'input o l'output del modello è stato bloccato. Se `blocked` è `true`, il campo `errors` nella risposta contiene uno o più codici di errore. Se `blocked` è `false`, la risposta non include il campo `errors`.
`categories`	Un elenco dei nomi delle categorie di attributi di sicurezza associati ai contenuti generati. L'ordine dei punteggi nel parametro `scores` corrisponde all'ordine delle categorie. Ad esempio, il primo punteggio nel parametro `scores` indica la probabilità che la risposta violi la prima categoria nell'elenco `categories`.
`citationMetadata`	Un elemento che contiene un array di citazioni.
`citations`	Un array di citazioni. Ogni citazione contiene i propri metadati.
`content`	Il risultato generato dal modello utilizzando il testo inserito.
`endIndex`	Un numero intero che specifica dove termina una citazione in `content`.
`errors`	Un array di codici di errore. Il campo di risposta `errors` è incluso nella risposta solo quando il campo `blocked` nella risposta è `true`. Per informazioni su come interpretare i codici di errore, consulta Errori relativi alla sicurezza.
`license`	La licenza associata a una citazione.
`publicationDate`	La data di pubblicazione di una citazione. I formati validi sono `YYYY`, `YYYY-MM` e `YYYY-MM-DD`.
`safetyAttributes`	Un array di attributi di sicurezza. L'array contiene un attributo di sicurezza per ogni risposta candidata.
`score`	Un valore `float` inferiore a zero. Maggiore è il valore di `score`, maggiore è la confidenza del modello nella sua risposta.
`startIndex`	Un numero intero che specifica dove inizia una citazione in `content`.
`title`	Il titolo di una fonte della citazione. Esempi di titoli delle fonti potrebbero essere quelli di un articolo di notizie o di un libro.
`url`	L'URL di una fonte della citazione. Alcuni esempi di origine URL sono un sito web di notizie o un repository GitHub.
`tokens`	I token campionati.
`tokenLogProbs`	Le probabilità in logaritmo dei token campionati.
`topLogProbs`	I token candidati più probabili e le relative probabilità in logaritmo in ogni passaggio.
`logprobs`	Risultati del parametro "logprobs". Mappatura 1:1 a "candidates".

Risposta di esempio

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

Streaming della risposta dai modelli di IA generativa

I parametri sono gli stessi per le richieste in streaming e non in streaming alle API.

Per visualizzare richieste e risposte di codice campione che utilizzano l'API REST, consulta Esempi di utilizzo dell'API REST in streaming.

Per visualizzare richieste e risposte di codice campione che utilizzano l'SDK Vertex AI per Python, consulta Esempi di utilizzo dell'SDK Vertex AI per Python per lo streaming.