Testare le richieste di generazione del codice

Per progettare un prompt che funzioni correttamente, testa diverse versioni del prompt e prova i relativi parametri per determinare quali risultati generano la risposta ottimale. Puoi testare i prompt in modo programmatico con le API Codey e nella console Google Cloud con Generative AI Studio.

Testare le richieste di generazione del codice

Per testare le richieste di generazione del codice, scegli uno dei seguenti metodi.

REST

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

Prima di utilizzare qualsiasi dato della richiesta, effettua le seguenti sostituzioni:

PROJECT_ID: il tuo ID progetto.
PREFIX: per i modelli di codice, prefix rappresenta l'inizio di una porzione di codice di programmazione significativo o di un prompt in linguaggio naturale che descrive il codice da generare.
TEMPERATURE: la temperatura viene utilizzata per il campionamento durante la generazione della risposta. La temperatura controlla il grado di casualità nella selezione dei token. Le temperature più basse sono ideali per le richieste che richiedono una risposta più deterministica e meno aperta o creativa, mentre le temperature più alte possono portare a risultati più diversificati o creativi. Una temperatura pari a 0 è deterministica, il che significa che viene sempre selezionata la risposta con la probabilità più alta.
MAX_OUTPUT_TOKENS: numero massimo di token che possono essere generati nella risposta. Un token è composto da circa quattro caratteri. 100 token corrispondono a circa 60-80 parole.
Specifica un valore più basso per le risposte più brevi e un valore più alto per le risposte più lunghe.
CANDIDATE_COUNT: il numero di varianti della risposta da restituire. Il parametro di conteggio dei candidati non è supportato quando utilizzi l'SDK Vertex AI. L'intervallo di valori validi è int compreso tra 1 e 4.

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:

arricciare

Nota: il seguente comando presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando di 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 ed esegui questo 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

Salva il corpo della richiesta in un file denominato request.json ed esegui questo 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

Dovresti ricevere una risposta JSON simile alla seguente.

Risposta

{
  "predictions": [
    {
      "citationMetadata": {
        "citations": []
      },
      "content": "RESPONSE",
      "safetyAttributes": {
        "blocked": false,
        "categories": [],
        "scores": []
      },
      "score": float
    }
  ]
}

SDK Vertex AI per Python

Per scoprire come installare l'SDK Vertex AI per Python, consulta Installare l'SDK Vertex AI per Python. Per saperne di più, consulta la documentazione di riferimento dell'SDK Vertex AI per l'API Python.

Visualizza su GitHub Feedback

from vertexai.preview.language_models import CodeGenerationModel

def generate_a_function(temperature: float = 0.5) -> object:
    """Example of using 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}")

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di Vertex AI sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Node.js Vertex AI.

Per l'autenticazione su Vertex AI, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta la pagina Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

/**
 * 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 di Java nella guida rapida di Vertex AI sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Java Vertex AI.

Per l'autenticazione su Vertex AI, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta la pagina Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback


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

Console

Per testare un prompt di generazione del codice utilizzando Generative AI Studio nella console Google Cloud:

Nella sezione Vertex AI della console Google Cloud, vai a Generative AI Studio.
Vai a Generative AI Studio
Fai clic su Inizia.
Fai clic su Crea prompt.
In Modello, seleziona il modello il cui nome inizia con code-bison. Un numero di tre cifre dopo code-bison indica il numero di versione del modello. Ad esempio, code-bison@001 è il nome della versione uno del modello di generazione del codice.
In Prompt, inserisci una richiesta di generazione del codice.
Regola la Temperatura e il Limite dei token per verificare in che modo influiscono sulla risposta. Per ulteriori informazioni, consulta Parametri del modello di generazione del codice.
Fai clic su Invia per generare una risposta.
Fai clic su Salva se vuoi salvare un prompt.
Fai clic su Visualizza codice per visualizzare il codice Python o un comando curl per il prompt.

Esempio di comando curl

MODEL_ID="code-bison"
PROJECT_ID=PROJECT_ID

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json"