Invia richieste di prompt di testo

Vertex AI ti consente di testare i prompt utilizzando Vertex AI Studio in la console Google Cloud, l'API Vertex AI e l'SDK Vertex AI per Python. Questa pagina mostra come testare i prompt di testo utilizzando una di queste interfacce.

Per scoprire di più sulla progettazione di prompt per il testo, consulta: Progettare prompt di testo.

Testare i prompt di testo

Per testare i prompt di testo, scegli uno dei seguenti metodi.

REST

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

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

  • PROJECT_ID: il tuo ID progetto.
  • PROMPT: Un prompt è una richiesta in linguaggio naturale inviata a un modello linguistico per ricevere una risposta. I prompt possono contenere domande, istruzioni, informazioni, esempi e testo per completare o continuare il modello. Non aggiungere virgolette intorno al prompt qui.
  • TEMPERATURE: La temperatura viene utilizzata per il campionamento durante la generazione della risposta, che si verifica quando topP e topK. La temperatura controlla il grado di casualità nella selezione dei token. Le temperature più basse sono ideali per prompt che richiedono una risposta meno aperta o creativa, mentre temperature più alte possono portare a risultati più diversificati o creativi. Una temperatura di 0 significa che vengono sempre selezionati i token con la probabilità più alta. In questo caso, le risposte per un determinato sono per lo più deterministici, ma è ancora possibile una piccola variazione.

    Se il modello restituisce una risposta troppo generica, troppo breve, oppure fornisce una risposta di riserva di risposta, prova ad aumentare la temperatura.

  • MAX_OUTPUT_TOKENS: Numero massimo di token che possono essere generati nella risposta. Un token è di 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 diverse.

  • TOP_P: Top-P cambia il modo in cui il modello seleziona i token per l'output. Token selezionati dal più probabile (vedi top-K) al meno probabile fino alla somma delle probabilità equivale al valore di top-P. Ad esempio, se i token A, B e C hanno una probabilità di 0,3, 0,2 e 0,1 e il valore di top-P è 0.5, il modello seleziona A o B come token successivo utilizzando la temperatura ed esclude C come candidato.

    Specifica un valore più basso per risposte meno casuali e un valore più alto per più risposte risposte casuali.

  • TOP_K: Top-K cambia il modo in cui il modello seleziona i token per l'output. Un top-K di 1 significa che il successivo token selezionato è il più probabile tra tutti nel vocabolario del modello (chiamato anche decodifica greedy), mentre una top-K di 3 significa che il token successivo viene selezionato tra i tre probabili token utilizzando la temperatura.

    Per ogni passaggio di selezione dei token, vengono mostrati i token top-K con il vengono campionate. Quindi i token vengono ulteriormente filtrati in base a top-P con il token finale selezionato utilizzando il campionamento della temperatura.

    Specifica un valore più basso per risposte meno casuali e un valore più alto per più risposte risposte casuali.

Metodo HTTP e URL:

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

Corpo JSON della richiesta:

{
  "instances": [
    { "prompt": "PROMPT"}
  ],
  "parameters": {
    "temperature": TEMPERATURE,
    "maxOutputTokens": MAX_OUTPUT_TOKENS,
    "topP": TOP_P,
    "topK": TOP_K
  }
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

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

Dovresti ricevere una risposta JSON simile alla seguente.

Esempio di comando text-bison curl

MODEL_ID="text-bison"
PROJECT_ID=PROJECT_ID

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://us-central1-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/us-central1/publishers/google/models/${MODEL_ID}:predict -d \
$'{
  "instances": [
    { "prompt": "Give me ten interview questions for the role of program manager." }
  ],
  "parameters": {
    "temperature": 0.2,
    "maxOutputTokens": 256,
    "topK": 40,
    "topP": 0.95
  }
}'

Python

Per scoprire come installare o aggiornare l'SDK Vertex AI per Python, vedi Installare l'SDK Vertex AI per Python. Per ulteriori informazioni, consulta documentazione di riferimento dell'API Python.

import vertexai

from vertexai.language_models import TextGenerationModel

# TODO(developer): Update project
vertexai.init(project=PROJECT_ID, location="us-central1")
parameters = {
    "temperature": 0.2,  # Temperature controls the degree of randomness in token selection.
    "max_output_tokens": 256,  # Token limit determines the maximum amount of text output.
    "top_p": 0.8,  # Tokens are selected from most probable to least until the sum of their probabilities equals the top_p value.
    "top_k": 40,  # A top_k of 1 means the selected token is the most probable among all tokens.
}

model = TextGenerationModel.from_pretrained("text-bison@002")
response = model.predict(
    "Give me ten interview questions for the role of program manager.",
    **parameters,
)
print(f"Response from Model: {response.text}")

return response.text

Go

Prima di provare questo esempio, segui le istruzioni per la configurazione di Go nel Guida rapida di Vertex AI con librerie client. Per ulteriori informazioni, consulta API Go Vertex AI documentazione di riferimento.

Per eseguire l'autenticazione su Vertex AI, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.


import (
	"context"
	"fmt"
	"io"

	aiplatform "cloud.google.com/go/aiplatform/apiv1beta1"
	"cloud.google.com/go/aiplatform/apiv1beta1/aiplatformpb"
	"google.golang.org/api/option"
	"google.golang.org/protobuf/types/known/structpb"
)

// textPredict generates text from prompt and configurations provided.
func textPredict(w io.Writer, prompt, projectID, location, publisher, model string, parameters map[string]interface{}) error {
	ctx := context.Background()

	apiEndpoint := fmt.Sprintf("%s-aiplatform.googleapis.com:443", location)

	client, err := aiplatform.NewPredictionClient(ctx, option.WithEndpoint(apiEndpoint))
	if err != nil {
		fmt.Fprintf(w, "unable to create prediction client: %v", err)
		return err
	}
	defer client.Close()

	// PredictRequest requires an endpoint, instances, and parameters
	// Endpoint
	base := fmt.Sprintf("projects/%s/locations/%s/publishers/%s/models", projectID, location, publisher)
	url := fmt.Sprintf("%s/%s", base, model)

	// Instances: the prompt to use with the text model
	promptValue, err := structpb.NewValue(map[string]interface{}{
		"prompt": prompt,
	})
	if err != nil {
		fmt.Fprintf(w, "unable to convert prompt to Value: %v", err)
		return err
	}

	// Parameters: the model configuration parameters
	parametersValue, err := structpb.NewValue(parameters)
	if err != nil {
		fmt.Fprintf(w, "unable to convert parameters to Value: %v", err)
		return err
	}

	// PredictRequest: create the model prediction request
	req := &aiplatformpb.PredictRequest{
		Endpoint:   url,
		Instances:  []*structpb.Value{promptValue},
		Parameters: parametersValue,
	}

	// PredictResponse: receive the response from the model
	resp, err := client.Predict(ctx, req)
	if err != nil {
		fmt.Fprintf(w, "error in prediction: %v", err)
		return err
	}

	fmt.Fprintf(w, "text-prediction response: %v", resp.Predictions[0])
	return nil
}

Java

Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nel Guida rapida di Vertex AI con librerie client. Per ulteriori informazioni, consulta API Java Vertex AI documentazione di riferimento.

Per eseguire l'autenticazione su Vertex AI, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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.Value;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class PredictTextPromptSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // Details of designing text prompts for supported large language models:
    // https://cloud.google.com/vertex-ai/docs/generative-ai/text/text-overview
    String instance =
        "{ \"prompt\": " + "\"Give me ten interview questions for the role of program manager.\"}";
    String parameters =
        "{\n"
            + "  \"temperature\": 0.2,\n"
            + "  \"maxOutputTokens\": 256,\n"
            + "  \"topP\": 0.95,\n"
            + "  \"topK\": 40\n"
            + "}";
    String project = "YOUR_PROJECT_ID";
    String location = "us-central1";
    String publisher = "google";
    String model = "text-bison@001";

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

  // Get a text prompt from a supported text model
  public static void predictTextPrompt(
      String instance,
      String parameters,
      String project,
      String location,
      String publisher,
      String model)
      throws IOException {
    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);

      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      Value.Builder instanceValue = Value.newBuilder();
      JsonFormat.parser().merge(instance, instanceValue);
      List<Value> instances = new ArrayList<>();
      instances.add(instanceValue.build());

      // Use Value.Builder to convert instance to a dynamically typed value that can be
      // processed by the service.
      Value.Builder parameterValueBuilder = Value.newBuilder();
      JsonFormat.parser().merge(parameters, parameterValueBuilder);
      Value parameterValue = parameterValueBuilder.build();

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

Node.js

Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nel Guida rapida di Vertex AI con librerie client. Per ulteriori informazioni, consulta API Node.js Vertex AI documentazione di riferimento.

Per eseguire l'autenticazione su Vertex AI, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 = 'text-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 = {
    prompt:
      'Give me ten interview questions for the role of program manager.',
  };
  const instanceValue = helpers.toValue(prompt);
  const instances = [instanceValue];

  const parameter = {
    temperature: 0.2,
    maxOutputTokens: 256,
    topP: 0.95,
    topK: 40,
  };
  const parameters = helpers.toValue(parameter);

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

  // Predict request
  const response = await predictionServiceClient.predict(request);
  console.log('Get text prompt response');
  console.log(response);
}

callPredict();

C#

Prima di provare questo esempio, segui le istruzioni per la configurazione di C# nel Guida rapida di Vertex AI con librerie client. Per ulteriori informazioni, consulta API C# Vertex AI documentazione di riferimento.

Per eseguire l'autenticazione su Vertex AI, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.


using Google.Cloud.AIPlatform.V1;
using System;
using System.Collections.Generic;
using System.Linq;
using Value = Google.Protobuf.WellKnownTypes.Value;

public class PredictTextPromptSample
{
    public string PredictTextPrompt(
        string projectId = "your-project-id",
        string locationId = "us-central1",
        string publisher = "google",
        string model = "text-bison@001"
    )
    {
        // Initialize client that will be used to send requests.
        // This client only needs to be created
        // once, and can be reused for multiple requests.
        var client = new PredictionServiceClientBuilder
        {
            Endpoint = $"{locationId}-aiplatform.googleapis.com"
        }.Build();

        // Configure the parent resource
        var endpoint = EndpointName.FromProjectLocationPublisherModel(projectId, locationId, publisher, model);

        // Initialize request argument(s)
        var prompt = "Give me ten interview questions for the role of program manager.";

        var instanceValue = Value.ForStruct(new()
        {
            Fields =
            {
                ["prompt"] = Value.ForString(prompt)
            }
        });

        var instances = new List<Value>
        {
            instanceValue
        };

        var parameters = Value.ForStruct(new()
        {
            Fields =
            {
                { "temperature", new Value { NumberValue = 0.2 } },
                { "maxOutputTokens", new Value { NumberValue = 256 } },
                { "topP", new Value { NumberValue = 0.95 } },
                { "topK", new Value { NumberValue = 40 } }
            }
        });

        // Make the request
        var response = client.Predict(endpoint, instances, parameters);

        // Parse and return the content.
        var content = response.Predictions.First().StructValue.Fields["content"].StringValue;
        Console.WriteLine($"Content: {content}");
        return content;
    }
}

Ruby

Prima di provare questo esempio, segui le istruzioni per la configurazione di Ruby nel Guida rapida di Vertex AI con librerie client. Per ulteriori informazioni, consulta API Ruby Vertex AI documentazione di riferimento.

Per eseguire l'autenticazione su Vertex AI, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

require "google/cloud/ai_platform/v1"

##
# Vertex AI Predict Text Prompt
#
# @param project_id [String] Your Google Cloud project (e.g. "my-project")
# @param location_id [String] Your Processor Location (e.g. "us-central1")
# @param publisher [String] The Model Publisher (e.g. "google")
# @param model [String] The Model Identifier (e.g. "text-bison@001")
#
def predict_text_prompt project_id:, location_id:, publisher:, model:
  # Create the Vertex AI client.
  client = ::Google::Cloud::AIPlatform::V1::PredictionService::Client.new do |config|
    config.endpoint = "#{location_id}-aiplatform.googleapis.com"
  end

  # Build the resource name from the project.
  endpoint = client.endpoint_path(
    project: project_id,
    location: location_id,
    publisher: publisher,
    model: model
  )

  prompt = "Give me ten interview questions for the role of program manager."

  # Initialize the request arguments
  instance = Google::Protobuf::Value.new(
    struct_value: Google::Protobuf::Struct.new(
      fields: {
        "prompt" => Google::Protobuf::Value.new(
          string_value: prompt
        )
      }
    )
  )

  instances = [instance]

  parameters = Google::Protobuf::Value.new(
    struct_value: Google::Protobuf::Struct.new(
      fields: {
        "temperature" => Google::Protobuf::Value.new(number_value: 0.2),
        "maxOutputTokens" => Google::Protobuf::Value.new(number_value: 256),
        "topP" => Google::Protobuf::Value.new(number_value: 0.95),
        "topK" => Google::Protobuf::Value.new(number_value: 40)
      }
    )
  )

  # Make the prediction request
  response = client.predict endpoint: endpoint, instances: instances, parameters: parameters

  # Handle the prediction response
  puts "Predict Response"
  puts response
end

Console

Per testare un prompt di testo utilizzando Vertex AI Studio nella Console Google Cloud, segui questi passaggi:

  1. Nella sezione Vertex AI della console Google Cloud, vai a la pagina Vertex AI Studio.

    Vai a Vertex AI Studio

  2. Fai clic sulla scheda Inizia.
  3. Fai clic su Prompt di testo.
  4. Seleziona il metodo di inserimento del prompt:

    • L'opzione Formato libero è consigliata per i prompt zero-shot o per il copia e incolla prompt few-shot.
    • L'impostazione Strutturata è consigliata per progettare prompt few-shot in Vertex AI Studio.

    In formato libero

    Inserisci il prompt nel campo di testo Prompt.

    Strutturati

    Il metodo strutturato per l'inserimento dei prompt separa i componenti di un prompt in campi diversi:

    • Contesto: inserisci le istruzioni per l'attività in cui vuoi che venga di eseguire e includere eventuali informazioni contestuali per il modello come riferimento.
    • Esempi: per i prompt few-shot, aggiungi esempi di input-output che modelli comportamentali da imitare. Aggiunta in corso... un prefisso per input e output di esempio è facoltativo. Se scegli di aggiungere prefissi, devono essere coerenti in tutti gli esempi.
    • Test: nel campo Input, inserisci l'input del prompt per cui vuoi ricevere una risposta. Aggiunta di un prefisso per il test input e output sono facoltativi. Se gli esempi hanno prefissi, il test devono avere gli stessi prefissi.
  5. Configura il modello e i parametri:

    • Modello: seleziona un modello text-bison o gemini-1.0-pro.
    • Temperatura: utilizza il cursore o la casella di testo per inserire un valore per la temperatura dell'acqua.

      La temperatura viene utilizzata per il campionamento durante la generazione della risposta, che si verifica quando topP e topK. La temperatura controlla il grado di casualità nella selezione dei token. Le temperature più basse sono ideali per prompt che richiedono una risposta meno aperta o creativa, mentre temperature più alte possono portare a risultati più diversificati o creativi. Una temperatura di 0 significa che vengono sempre selezionati i token con la probabilità più alta. In questo caso, le risposte per un determinato sono per lo più deterministici, ma è ancora possibile una piccola variazione.

      Se il modello restituisce una risposta troppo generica, troppo breve, oppure fornisce una risposta di riserva di risposta, prova ad aumentare la temperatura.

    • Limite di token. Utilizza il dispositivo di scorrimento o la casella di testo per inserire un valore per il parametro limite massimo di output.

      Numero massimo di token che possono essere generati nella risposta. Un token è di 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 diverse.

    • Top-K: utilizza il cursore o la casella di testo per inserire un valore per top-K.

      Top-K cambia il modo in cui il modello seleziona i token per l'output. Un top-K di 1 significa che il successivo token selezionato è il più probabile tra tutti nel vocabolario del modello (chiamato anche decodifica greedy), mentre una top-K di 3 significa che il token successivo viene selezionato tra i tre probabili token utilizzando la temperatura.

      Per ogni passaggio di selezione dei token, vengono mostrati i token top-K con il vengono campionate. Quindi i token vengono ulteriormente filtrati in base a top-P con il token finale selezionato utilizzando il campionamento della temperatura.

      Specifica un valore più basso per risposte meno casuali e un valore più alto per più risposte risposte casuali.

    • Top-P: utilizza il cursore o la casella di testo per inserire un valore per top-P. I token vengono selezionati dal più probabile al meno probabile fino alla somma dei loro le probabilità equivalgono al valore di top-P. Per ottenere risultati meno variabili, imposta top-P su 0.
  6. Fai clic su Invia.
  7. (Facoltativo) Per salvare il prompt in I miei prompt, fai clic su Salva.
  8. (Facoltativo) Per ottenere il codice Python o un comando curl per il prompt, fai clic su Visualizza codice.

Flusso di risposta da modello di testo

Per visualizzare richieste di codice e risposte di esempio utilizzando l'API REST, consulta Esempi di utilizzo dell'API REST.

Per visualizzare richieste di codice e risposte di esempio utilizzando l'SDK Vertex AI per Python, consulta Esempi di utilizzo dell'SDK Vertex AI per Python.

Passaggi successivi