Requêtes "Envoyer des invites textuelles"

Vertex AI vous permet de tester des requêtes à l'aide de Vertex AI Studio dans la console Google Cloud, l'API Vertex AI et le SDK Vertex AI pour Python. Cette page explique comment tester des requêtes de texte à l'aide de l'une de ces interfaces.

Pour en savoir plus sur la conception de requêtes de texte, consultez la section Concevoir des requêtes de texte.

Tester des requêtes textuelles

Pour tester les requêtes de texte, choisissez l'une des méthodes suivantes.

REST

Pour tester une requête de texte à l'aide de l'API Vertex AI, envoyez une requête POST au point de terminaison du modèle de l'éditeur.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

PROJECT_ID : l'ID de votre projet.
PROMPT : une requête est une requête en langage naturel envoyée à un modèle de langage pour recevoir une réponse. Les requêtes peuvent contenir des questions, des instructions, des informations contextuelles, des exemples et du texte pour le modèle à terminer ou à continuer. (N'ajoutez pas de guillemets autour de la requête ici.)
TEMPERATURE : La température est utilisée pour l'échantillonnage pendant la génération des réponses, qui se produit lorsque topP et topK sont appliqués. La température permet de contrôler le degré de hasard dans la sélection des jetons. Les températures inférieures sont idéales pour les requêtes qui nécessitent une réponse moins ouverte ou créative, tandis que des températures plus élevées peuvent conduire à des résultats plus diversifiés ou créatifs. Une température de 0 signifie que les jetons de probabilité les plus élevés sont toujours sélectionnés. Dans ce cas, les réponses pour une requête donnée sont principalement déterministes, mais une petite quantité de variation est toujours possible.
Si le modèle renvoie une réponse trop générique ou trop courte, ou s'il renvoie une réponse de remplacement, essayez d'augmenter la température.
MAX_OUTPUT_TOKENS : nombre maximal de jetons pouvant être générés dans la réponse. Un jeton correspond environ à quatre caractères. 100 jetons correspondent à environ 60-80 mots.
Spécifiez une valeur inférieure pour obtenir des réponses plus courtes et une valeur supérieure pour des réponses potentiellement plus longues.
TOP_P : top P modifie la façon dont le modèle sélectionne les jetons pour la sortie. Les jetons sont sélectionnés de la valeur la plus élevée (voir top-K) à la moins probable jusqu'à ce que la somme de leurs probabilités soit égale à la valeur top-P. Par exemple, si les jetons A, B et C ont une probabilité de 0,3, 0,2 et 0,1 et que la valeur de top-P est supérieure à 0.5, le modèle sélectionne A ou B comme jeton suivant en utilisant la température et exclut C comme candidat.
Spécifiez une valeur inférieure pour les réponses moins aléatoires et une valeur plus élevée pour les réponses plus aléatoires.
TOP_K : top K modifie la façon dont le modèle sélectionne les jetons pour la sortie. Un top-K de 1 signifie que le prochain jeton sélectionné est le plus probable parmi tous les jetons du vocabulaire du modèle (également appelé décodage gourmand), tandis que le top-K de 3 signifie que le jeton suivant est sélectionné parmi les trois jetons les plus probables en utilisant la température.
Pour chaque étape de sélection du jeton, les jetons top-K avec les probabilités les plus élevées sont échantillonnés. Les jetons sont ensuite filtrés en fonction du top-P avec le jeton final sélectionné à l'aide de l'échantillonnage de température.

Spécifiez une valeur inférieure pour les réponses moins aléatoires et une valeur plus élevée pour les réponses plus aléatoires.

Méthode HTTP et URL :

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

Corps JSON de la requête :

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

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

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

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$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

Vous devriez recevoir une réponse JSON semblable à la suivante.

Réponse

{
  "predictions": [
    {
      "content": "RESPONSE"
      "citationMetadata": {
        "citations": []
      },
      "safetyAttributes": {
        "scores": [],
        "blocked": false,
        "categories": []
      }
    }
  ],
  "metadata": {
    "tokenMetadata": {
      "inputTokenCount": {
        "totalBillableCharacters": ,
        "totalTokens": 
      },
      "outputTokenCount": {
        "totalBillableCharacters": ,
        "totalTokens": 
      }
    }
  }
}

Exemple de commande curl text-bison

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

Pour savoir comment installer ou mettre à jour le SDK Vertex AI pour Python, consultez la section Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'API Python.

import vertexai

from vertexai.language_models import TextGenerationModel

# TODO(developer): Update values for project_id, location & temperature
vertexai.init(project=project_id, location=location)
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.
    "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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Go décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Go.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.


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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Java.


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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Node.js.

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

Avant d'essayer cet exemple, suivez les instructions de configuration pour C# décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI C#.


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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Ruby décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Ruby.

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

Pour tester une requête de texte à l'aide de Vertex AI Studio dans la console Google Cloud, procédez comme suit :

Dans la section "Vertex AI" de la console Google Cloud, accédez à la page Vertex AI Studio.
Accéder à Vertex AI Studio
Cliquez sur l'onglet Premiers pas.
Cliquez sur Requête de texte
Sélectionnez la méthode de saisie de la requête :
- Format libre est recommandé pour les requêtes zero-shot ou pour copier-coller les requêtes few-shot.
- Structuré est recommandé pour concevoir des requêtes few-shot dans Vertex AI Studio.
Forme libre

Saisissez la requête dans le champ de texte Requête.
Structurées

La méthode structurée de saisie des requêtes sépare les composants d'une requête dans différents champs :
- Contexte : saisissez des instructions pour la tâche que vous souhaitez que le modèle exécute, et incluez toutes les informations contextuelles que le modèle doit référencer.
- Exemples : pour les requêtes few-shot, ajoutez des exemples d'entrées/sortie qui illustrent les modèles de comportement à imiter par le modèle. L'ajout d'un préfixe pour l'exemple d'entrée et de sortie est facultatif. Si vous choisissez d'ajouter des préfixes, ils doivent être cohérents sur tous les exemples.
- Test : Dans le champ Entrée, saisissez l'entrée de la requête pour laquelle vous souhaitez obtenir une réponse. L'ajout d'un préfixe pour les données d'entrée et de sortie de test est facultatif. Si vos exemples comportent des préfixes, le test doit avoir les mêmes préfixes.
Configurez le modèle et les paramètres :
- Modèle : sélectionnez un modèle text-bison ou gemini-1.0-pro.
- Température : utilisez le curseur ou la zone de texte pour saisir une valeur de température.
  La température est utilisée pour l'échantillonnage pendant la génération des réponses, qui se produit lorsque topP et topK sont appliqués. La température permet de contrôler le degré de hasard dans la sélection des jetons. Les températures inférieures sont idéales pour les requêtes qui nécessitent une réponse moins ouverte ou créative, tandis que des températures plus élevées peuvent conduire à des résultats plus diversifiés ou créatifs. Une température de 0 signifie que les jetons de probabilité les plus élevés sont toujours sélectionnés. Dans ce cas, les réponses pour une requête donnée sont principalement déterministes, mais une petite quantité de variation est toujours possible.
  Si le modèle renvoie une réponse trop générique ou trop courte, ou s'il renvoie une réponse de remplacement, essayez d'augmenter la température.
- Limite de jeton : utilisez le curseur ou la zone de texte pour saisir une valeur correspondant à la limite maximale de sortie.
  Nombre maximal de jetons pouvant être générés dans la réponse. Un jeton correspond environ à quatre caractères. 100 jetons correspondent à environ 60-80 mots.
  Spécifiez une valeur inférieure pour obtenir des réponses plus courtes et une valeur supérieure pour des réponses potentiellement plus longues.
- Top-K : saisissez une valeur pour le top-K à l'aide du curseur ou de la zone de texte.
  Top K modifie la façon dont le modèle sélectionne les jetons pour la sortie. Une valeur top-K de 1 signifie que le prochain jeton sélectionné est le plus probable parmi tous les jetons du vocabulaire du modèle (également appelé décodage glouton), tandis qu'une valeur top-K de 3 signifie que le jeton suivant est sélectionné parmi les trois jetons les plus probables en utilisant la température.
  Pour chaque étape de sélection du jeton, les jetons top-K avec les probabilités les plus élevées sont échantillonnés. Les jetons sont ensuite filtrés en fonction du top-P avec le jeton final sélectionné à l'aide de l'échantillonnage de température.
  
  Spécifiez une valeur inférieure pour les réponses moins aléatoires et une valeur plus élevée pour les réponses plus aléatoires.
- Top-P : utilisez le curseur ou la zone de texte pour saisir une valeur. Les jetons sont sélectionnés de la probabilité la plus élevée jusqu'à ce que la somme de leurs probabilités soit égale à la valeur de top-P. Pour obtenir les résultats les moins variables, définissez "top-P" sur 0.
Cliquez sur Submit (Envoyer).
Facultatif : Pour enregistrer votre requête dans Mes requêtes, cliquez sur Enregistrer.
Facultatif : Pour obtenir le code Python ou la commande curl de votre requête, cliquez sur Afficher le code.

Réponse en streaming à partir d'un modèle textuel

Pour afficher des exemples de code de requêtes et de réponses avec l'API REST, consultez la page Exemples d'utilisation de l'API REST.

Pour afficher des exemples de requêtes et de réponses de code à l'aide du SDK Vertex AI pour Python, consultez la page Exemples d'utilisation du SDK Vertex AI pour Python.

Étapes suivantes

Découvrez comment envoyer des requêtes d'invites de chat Gemini.
Découvrez comment tester les requêtes de chat.
Découvrez comment ajuster un modèle de fondation.
Découvrez les bonnes pratiques d'IA responsable et les filtres de sécurité de Vertex AI.

Requêtes "Envoyer des invites textuelles"

Tester des requêtes textuelles

REST

curl

PowerShell

Réponse

Exemple de commande curl text-bison

Python

Go

Java

Node.js

C#

Ruby

Console

Forme libre

Structurées

Réponse en streaming à partir d'un modèle textuel

Étapes suivantes