Envoyer des requêtes de chat (Gemini)

Cette page vous explique comment envoyer des requêtes de chat au modèle Gemini 1.0 Pro (gemini-1.0-pro) à l'aide de la console Google Cloud, de l'API REST et des SDK compatibles. Gemini 1.0 Pro accepte les requêtes avec des entrées de type texte uniquement, y compris les tâches en langage naturel, le chat textuel et de code multitour, et la génération de code. Il peut générer du texte et du code en sortie.

Le modèle de fondation Gemini 1.0 Pro est un grand modèle de langage qui excelle dans la compréhension et la génération de langues. Vous pouvez interagir avec Gemini Pro à l'aide d'une requête et d'une réponse à un seul tour, ou discuter avec lui dans une conversation continue et multitours, même pour la compréhension et la génération de code.

Pour obtenir la liste des langues compatibles avec Gemini 1.0 Pro, consultez les informations sur le modèle dans la section Langues acceptées.

Pour explorer ce modèle dans la console, sélectionnez la fiche de modèle gemini-1.0-pro dans Model Garden.

Accéder à Model Garden

Si vous cherchez un moyen d'utiliser Gemini directement depuis vos applications mobiles et Web, consultez la section SDK d'IA de Google pour Android, Swift et le Web.

Envoyer des requêtes de chat

Pour tester et effectuez des itérations de requêtes de chat, nous vous recommandons d'utiliser la console Google Cloud. Pour envoyer des requêtes de façon programmatique au modèle, vous pouvez utiliser l'API REST, le SDK Vertex AI pour Python, ou l'une des autres bibliothèques et SDK compatibles présentés dans les onglets suivants.

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 SDK Vertex AI pour Python.

Réponses en streaming et sans streaming

Vous pouvez choisir si le modèle génère une réponse en streaming ou sans streaming. Le streaming implique de recevoir des réponses aux requêtes au fur et à mesure de leur génération. Autrement dit, les jetons de sortie sont envoyés dès lors qu'ils ont été générés par le modèle. Une réponse aux requêtes sans streaming n'est envoyée qu'une fois tous les jetons de sortie générés.

Pour une réponse en streaming, utilisez le paramètre stream dans generate_content.

  response = model.generate_content(contents=[...], stream = True)

Pour une réponse sans streaming, supprimez le paramètre ou définissez-le sur False.

Exemple de code

import vertexai

from vertexai.generative_models import GenerativeModel, ChatSession

# TODO(developer): Update and un-comment below lines
# project_id = "PROJECT_ID"
# location = "us-central1"
vertexai.init(project=project_id, location=location)
model = GenerativeModel(model_name="gemini-1.0-pro-002")
chat = model.start_chat()

def get_chat_response(chat: ChatSession, prompt: str) -> str:
    text_response = []
    responses = chat.send_message(prompt, stream=True)
    for chunk in responses:
        text_response.append(chunk.text)
    return "".join(text_response)

prompt = "Hello."
print(get_chat_response(chat, prompt))

prompt = "What are all the colors in a rainbow?"
print(get_chat_response(chat, prompt))

prompt = "Why does it appear when it rains?"
print(get_chat_response(chat, prompt))

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#.

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. 


using Google.Cloud.AIPlatform.V1;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

public class MultiTurnChatSample
{
    public async Task<string> GenerateContent(
        string projectId = "your-project-id",
        string location = "us-central1",
        string publisher = "google",
        string model = "gemini-1.0-pro"
    )
    {
        // Create a chat session to keep track of the context
        ChatSession chatSession = new ChatSession($"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}", location);

        string prompt = "Hello.";
        Console.WriteLine($"\nUser: {prompt}");

        string response = await chatSession.SendMessageAsync(prompt);
        Console.WriteLine($"Response: {response}");

        prompt = "What are all the colors in a rainbow?";
        Console.WriteLine($"\nUser: {prompt}");

        response = await chatSession.SendMessageAsync(prompt);
        Console.WriteLine($"Response: {response}");

        prompt = "Why does it appear when it rains?";
        Console.WriteLine($"\nUser: {prompt}");

        response = await chatSession.SendMessageAsync(prompt);
        Console.WriteLine($"Response: {response}");

        return response;
    }

    private class ChatSession
    {
        private readonly string _modelPath;
        private readonly PredictionServiceClient _predictionServiceClient;

        private readonly List<Content> _contents;

        public ChatSession(string modelPath, string location)
        {
            _modelPath = modelPath;

            // Create a prediction service client.
            _predictionServiceClient = new PredictionServiceClientBuilder
            {
                Endpoint = $"{location}-aiplatform.googleapis.com"
            }.Build();

            // Initialize contents to send over in every request.
            _contents = new List<Content>();
        }

        public async Task<string> SendMessageAsync(string prompt)
        {
            // Initialize the content with the prompt.
            var content = new Content
            {
                Role = "USER"
            };
            content.Parts.AddRange(new List<Part>()
            {
                new() {
                    Text = prompt
                }
            });
            _contents.Add(content);

            // Create a request to generate content.
            var generateContentRequest = new GenerateContentRequest
            {
                Model = _modelPath,
                GenerationConfig = new GenerationConfig
                {
                    Temperature = 0.9f,
                    TopP = 1,
                    TopK = 32,
                    CandidateCount = 1,
                    MaxOutputTokens = 2048
                }
            };
            generateContentRequest.Contents.AddRange(_contents);

            // Make a non-streaming request, get a response.
            GenerateContentResponse response = await _predictionServiceClient.GenerateContentAsync(generateContentRequest);

            // Save the content from the response.
            _contents.Add(response.Candidates[0].Content);

            // Return the text
            return response.Candidates[0].Content.Parts[0].Text;
        }
    }
}

Node.js

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js du guide de démarrage rapide de l'IA générative à l'aide du SDK Node.js. Pour en savoir plus, consultez la documentation de référence du SDK Node.js pour Gemini.

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.

Réponses en streaming et sans streaming

Vous pouvez choisir si le modèle génère une réponse en streaming ou sans streaming. Le streaming implique de recevoir des réponses aux requêtes au fur et à mesure de leur génération. Autrement dit, les jetons de sortie sont envoyés dès lors qu'ils ont été générés par le modèle. Une réponse aux requêtes sans streaming n'est envoyée qu'une fois tous les jetons de sortie générés.

Pour une réponse en streaming, utilisez la méthode generateContentStream.

  const streamingResp = await generativeModel.generateContentStream(request);

Pour une réponse non affichée progressivement, utilisez la méthode generateContent.

  const streamingResp = await generativeModel.generateContent(request);

Exemple de code

const {VertexAI} = require('@google-cloud/vertexai');

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function createStreamChat(
  projectId = 'PROJECT_ID',
  location = 'us-central1',
  model = 'gemini-1.0-pro'
) {
  // Initialize Vertex with your Cloud project and location
  const vertexAI = new VertexAI({project: projectId, location: location});

  // Instantiate the model
  const generativeModel = vertexAI.getGenerativeModel({
    model: model,
  });

  const chat = generativeModel.startChat({});
  const chatInput1 = 'How can I learn more about that?';

  console.log(`User: ${chatInput1}`);

  const result1 = await chat.sendMessageStream(chatInput1);
  for await (const item of result1.stream) {
    console.log(item.candidates[0].content.parts[0].text);
  }
}

Java

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java du guide de démarrage rapide de Vertex AI. Pour en savoir plus, consultez la documentation de référence du SDK Vertex AI pour Java pour Gemini.

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.

Réponses en streaming et sans streaming

Vous pouvez choisir si le modèle génère une réponse en streaming ou sans streaming. Le streaming implique de recevoir des réponses aux requêtes au fur et à mesure de leur génération. Autrement dit, les jetons de sortie sont envoyés dès lors qu'ils ont été générés par le modèle. Une réponse aux requêtes sans streaming n'est envoyée qu'une fois tous les jetons de sortie générés.

Pour une réponse en streaming, utilisez la méthode generateContentStream.

  public ResponseStream generateContentStream(Content content)

Pour une réponse non affichée progressivement, utilisez la méthode generateContent.

  public GenerateContentResponse generateContent(Content content)

Exemple de code

import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.api.GenerateContentResponse;
import com.google.cloud.vertexai.generativeai.ChatSession;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.ResponseHandler;
import java.io.IOException;

public class ChatDiscussion {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-google-cloud-project-id";
    String location = "us-central1";
    String modelName = "gemini-1.0-pro";

    chatDiscussion(projectId, location, modelName);
  }

  // Ask interrelated questions in a row using a ChatSession object.
  public static void chatDiscussion(String projectId, String location, String modelName)
      throws IOException {
    // 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 (VertexAI vertexAI = new VertexAI(projectId, location)) {
      GenerateContentResponse response;

      GenerativeModel model = new GenerativeModel(modelName, vertexAI);
      // Create a chat session to be used for interactive conversation.
      ChatSession chatSession = new ChatSession(model);

      response = chatSession.sendMessage("Hello.");
      System.out.println(ResponseHandler.getText(response));

      response = chatSession.sendMessage("What are all the colors in a rainbow?");
      System.out.println(ResponseHandler.getText(response));

      response = chatSession.sendMessage("Why does it appear when it rains?");
      System.out.println(ResponseHandler.getText(response));
      System.out.println("Chat Ended.");
    }
  }
}

Go

Avant d'essayer cet exemple, suivez les instructions de configuration pour Go du guide de démarrage rapide de Vertex AI. Pour en savoir plus, consultez la documentation de référence du SDK Vertex AI pour Go pour Gemini.

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.

Réponses en streaming et sans streaming

Vous pouvez choisir si le modèle génère une réponse en flux ou pas. Le streaming implique de recevoir des réponses aux requêtes au fur et à mesure de leur génération. Autrement dit, les jetons de sortie sont envoyés dès lors qu'ils ont été générés par le modèle. Une réponse aux requêtes sans streaming n'est envoyée qu'une fois tous les jetons de sortie générés.

Pour une réponse en streaming, utilisez la méthode GenerateContentStream.

  iter := model.GenerateContentStream(ctx, genai.Text("Tell me a story about a lumberjack and his giant ox. Keep it very short."))

Pour une réponse non affichée progressivement, utilisez la méthode GenerateContent.

  resp, err := model.GenerateContent(ctx, genai.Text("What is the average size of a swallow?"))

Exemple de code

import (
	"context"
	"encoding/json"
	"fmt"
	"io"

	"cloud.google.com/go/vertexai/genai"
)

func makeChatRequests(w io.Writer, projectID string, location string, modelName string) error {
	// location := "us-central1"
	// modelName := "gemini-1.0-pro-002"
	ctx := context.Background()
	client, err := genai.NewClient(ctx, projectID, location)
	if err != nil {
		return fmt.Errorf("error creating client: %w", err)
	}
	defer client.Close()

	gemini := client.GenerativeModel(modelName)
	chat := gemini.StartChat()

	r, err := chat.SendMessage(
		ctx,
		genai.Text("Hello"))
	if err != nil {
		return err
	}
	rb, err := json.MarshalIndent(r, "", "  ")
	if err != nil {
		return fmt.Errorf("json.MarshalIndent: %w", err)
	}
	fmt.Fprintln(w, string(rb))

	r, err = chat.SendMessage(
		ctx,
		genai.Text("What are all the colors in a rainbow?"))
	if err != nil {
		return err
	}
	rb, err = json.MarshalIndent(r, "", "  ")
	if err != nil {
		return fmt.Errorf("json.MarshalIndent: %w", err)
	}
	fmt.Fprintln(w, string(rb))

	r, err = chat.SendMessage(
		ctx,
		genai.Text("Why does it appear when it rains?"))
	if err != nil {
		return fmt.Errorf("chat.SendMessage: %w", err)
	}
	rb, err = json.MarshalIndent(r, "", "  ")
	if err != nil {
		return fmt.Errorf("json.MarshalIndent: %w", err)
	}
	fmt.Fprintln(w, string(rb))

	return nil
}

REST

Vous pouvez utiliser REST pour envoyer une requête de chat à l'aide de l'API Vertex AI pour envoyer 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 :

  • GENERATE_RESPONSE_METHOD : type de réponse que le modèle doit générer. Choisissez une méthode qui génère le mode de renvoi de la réponse du modèle :
    • streamGenerateContent : la réponse est affichée progressivement à mesure qu'elle est générée afin de réduire la perception de la latence auprès d'un public humain.
    • generateContent : la réponse est renvoyée une fois qu'elle a été entièrement générée.
  • LOCATION : région dans laquelle traiter la requête. Les options disponibles sont les suivantes :

    Cliquer pour développer les régions disponibles

    • us-central1
    • us-west4
    • northamerica-northeast1
    • us-east4
    • us-west1
    • asia-northeast3
    • asia-southeast1
    • asia-northeast1
  • PROJECT_ID : l'ID de votre projet.
  • MODEL_ID : ID du modèle multimodal que vous souhaitez utiliser. Vous disposez des options suivantes :
    • gemini-1.0-pro-002
    • gemini-1.0-pro-vision-001
    • gemini-1.5-pro-preview-0409
  • ROLE : rôle dans une conversation associée au contenu. La spécification d'un rôle est requise, même dans les cas d'utilisation à un seul tour. Les valeurs acceptées incluent les suivantes :
    • USER : spécifie le contenu envoyé par vous.
    • MODEL : spécifie la réponse du modèle.
  • TEXT : instructions textuelles à inclure dans la requête.
  • SAFETY_CATEGORY : catégorie de sécurité pour laquelle configurer un seuil. Les valeurs acceptées incluent les suivantes :

    Cliquer pour développer les catégories de sécurité

    • HARM_CATEGORY_SEXUALLY_EXPLICIT
    • HARM_CATEGORY_HATE_SPEECH
    • HARM_CATEGORY_HARASSMENT
    • HARM_CATEGORY_DANGEROUS_CONTENT
  • THRESHOLD : seuil de blocage des réponses susceptibles d'appartenir à la catégorie de sécurité spécifiée en fonction de la probabilité. Les valeurs acceptées incluent les suivantes :

    Cliquer pour développer les seuils de blocage

    • BLOCK_NONE
    • BLOCK_ONLY_HIGH
    • BLOCK_MEDIUM_AND_ABOVE (par défaut)
    • BLOCK_LOW_AND_ABOVE
     BLOCK_LOW_AND_ABOVE bloque le plus, tandis que BLOCK_ONLY_HIGH bloque le moins.
  • SYSTEM_INSTRUCTION: (facultatif) disponible pour gemini-1.0-pro-002 et gemini-1.5-pro-preview-0409. Instructions permettant au modèle de l'orienter vers de meilleures performances. Par exemple, "Répondez aussi précisément que possible" ou "Imprimer les résultats au format JSON".
  • 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.

  • 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.

  • 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.

  • STOP_SEQUENCES : spécifie une liste de chaînes qui indiquent au modèle d'arrêter de générer du texte si l'une des chaînes est détectée dans la réponse. Si une chaîne apparaît plusieurs fois dans la réponse, celle-ci effectue une troncation lors de la première rencontre. Les chaînes sont sensibles à la casse.

    Par exemple, si la réponse suivante est renvoyée lorsque stopSequences n'est pas spécifié :

    public static string reverse(string myString)

    La réponse renvoyée avec stopSequences défini sur ["Str", "reverse"] est alors la suivante :

    public static string

Méthode HTTP et URL :

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:GENERATE_RESPONSE_METHOD

Corps JSON de la requête : 

{
  "contents": {
    "role": "ROLE",
    "parts": { "text": "TEXT" }
  },
  "system_instruction":
  {
    "parts": [
      {
        "text": "SYSTEM_INSTRUCTION"
      }
    ]
  },
  "safety_settings": {
    "category": "SAFETY_CATEGORY",
    "threshold": "THRESHOLD"
  },
  "generation_config": {
    "temperature": TEMPERATURE,
    "topP": TOP_P,
    "topK": TOP_K,
    "candidateCount": 1,
    "maxOutputTokens": MAX_OUTPUT_TOKENS,
    "stopSequences": STOP_SEQUENCES,
  }
}

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

curl

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://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:GENERATE_RESPONSE_METHOD"

PowerShell

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://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:GENERATE_RESPONSE_METHOD" | Select-Object -Expand Content

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

Exemple de commande curl

LOCATION="us-central1"
MODEL_ID="gemini-1.0-pro"
PROJECT_ID="test-project"
GENERATE_RESPONSE_METHOD="generateContent"

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/google/models/${MODEL_ID}:${GENERATE_RESPONSE_METHOD} -d \
$'{
  "contents": [
    {
    "role": "user",
    "parts": { "text": "Hello!" }
    },
    {
    "role": "model",
    "parts": { "text": "Argh! What brings ye to my ship?" }
    },
    {
    "role": "user",
    "parts": { "text": "Wow! You are a real-life pirate!" }
    }
  ],
  "safety_settings": {
    "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
    "threshold": "BLOCK_LOW_AND_ABOVE"
  },
  "generation_config": {
    "temperature": 0.9,
    "topP": 1,
    "candidateCount": 1,
    "maxOutputTokens": 2048
  }
}'

Console

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

  1. Dans la section Vertex AI de la console Google Cloud, accédez à la page Langue de Vertex AI Studio.

    Accéder à Vertex AI Studio

  2. Cliquez sur Chat textuel.

  3. Configurez le modèle et les paramètres :

    • Région : sélectionnez la région que vous souhaitez utiliser.
    • Modèle : sélectionnez Gemini 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.

    • Ajouter une séquence d'arrêt : saisissez une séquence d'arrêt, qui est une série de caractères (espaces compris) qui arrête la génération de réponse si le modèle la rencontre. La séquence n'est pas incluse dans la réponse. Vous pouvez ajouter jusqu'à cinq séquences d'arrêt.
  4. Facultatif : pour configurer les paramètres avancés, cliquez sur Avancé, puis configurez les paramètres comme suit :

    Cliquez pour développer les configurations avancées

    • 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 du plus probable au moins probable, 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.

  5. La console Google Cloud n'est compatible qu'avec le streaming, qui implique la réception de réponses aux requêtes au fur et à mesure de leur génération. Vous êtes prêt à saisir un message dans la zone de message pour démarrer une conversation avec le modèle.

    Le modèle utilise les messages précédents comme contexte pour les nouvelles réponses.

  6. Facultatif : pour enregistrer votre requête dans Mes requêtes, cliquez sur Enregistrer.
  7. Facultatif : pour obtenir le code Python ou la commande curl de votre requête, cliquez sur  Obtenir le code.
  8. Facultatif : pour effacer tous les messages précédents, cliquez sur  Effacer la conversation.

Utiliser les instructions système

Les instructions système permettent aux utilisateurs d'orienter le comportement du modèle en fonction de leurs besoins et de leurs cas d'utilisation spécifiques. Lorsque vous définissez une instruction système, vous donnez au modèle davantage de contexte pour comprendre la tâche, fournir des réponses plus personnalisées et respecter des consignes spécifiques concernant l'interaction complète de l'utilisateur avec le modèle. Pour les développeurs, le comportement au niveau du produit peut être spécifié dans des instructions système, indépendamment des requêtes fournies par les utilisateurs finaux.

Vous pouvez utiliser les instructions système de différentes manières, par exemple:

  • Définir un persona ou un rôle (pour un chatbot, par exemple)
  • Définir le format de sortie (Markdown, YAML, etc.)
  • Définir le style et le ton de sortie (par exemple, la verbosité, la formalité et le niveau de lecture cible)
  • Définir des objectifs ou des règles pour la tâche (par exemple, renvoyer un extrait de code sans autre explication)
  • Fournir du contexte supplémentaire pour la requête (par exemple, une limite de connaissances)

Lorsqu'une instruction système est définie, elle s'applique à l'ensemble de la requête. Elle fonctionne sur plusieurs tours d'utilisateur et de modèle lorsqu'elle est incluse dans la requête.

Exemples de code pour les instructions système

Vous trouverez ci-dessous un exemple de spécification d'instructions système simples lors de l'utilisation du SDK Vertex AI pour Python.

from vertexai.generative_models import GenerativeModel
model = GenerativeModel(
    "gemini-1.0-pro-002",
    system_instruction=[
        "Don't use technical terms in your response",
    ],
)
print(model.generate_content("Explain gravity"))

Voici un exemple d'inclusion d'une instruction système simple dans une commande curl.

LOCATION="us-central1"
MODEL_ID="gemini-1.0-pro-002"
PROJECT_ID="test-project"
GENERATE_RESPONSE_METHOD="generateContent"

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
"https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/google/models:generateContent" -d \
{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "randomly select 10 words from a history book"
        }
      ]
    }
  ],
  "system_instruction":
    {
      "parts": [
        {
          "text": "please print the results in json format."
        }
      ]
    },
  "generation_config": {
    "maxOutputTokens": 2048,
    "temperature": 0.4,
    "topP": 1,
    "topK": 32
  }
}

Exemples d'instructions système

Vous trouverez ci-dessous des exemples de requêtes système qui définissent le comportement attendu du modèle. La première est une requête système pour la génération de code d'interface, la deuxième est un exemple de cas d'utilisation d'analyse des sentiments du marché et la troisième est un chatbot de consommateur.

Génération de code

  • Système: vous êtes un expert en codage spécialisé dans le rendu de code pour les interfaces frontend. Lorsque je décris un composant d'un site Web que je souhaite créer, veuillez renvoyer le code HTML et CSS nécessaire. Ne fournissez pas d'explications sur ce code. Fournissez également des suggestions de conception de l'interface utilisateur.
  • Utilisateur: crée une zone au milieu de la page contenant une sélection d'images qui alterne et avec une légende. L'image au centre de la page doit avoir un ombrage derrière pour la faire apparaître. Elle doit également renvoyer vers une autre page du site. Laissez l'URL vide afin que je puisse la renseigner.

Analyse des sentiments du marché

  • Système: vous êtes un analyste boursier qui analyse les sentiments du marché à partir d'un extrait d'actualités. En vous basant sur l'extrait d'actualités, vous extrayez les déclarations ayant un impact sur le sentiment des investisseurs.

    Répondez au format JSON et pour chaque instruction:

    • Attribuez un score de 1 à 10 pour indiquer si le sentiment est négatif ou positif (1 correspond au plus négatif, 10 correspond au plus positif, 5 est neutre).
    • Réitérez l'énoncé.
    • Expliquez en une phrase.

  • Utilisateur: Mobileye a signalé une accumulation d'inventaire excédentaire par des clients de premier plan dans le respect des contraintes de la chaîne d'approvisionnement au cours des dernières années. Les revenus du premier trimestre devraient diminuer d'environ 50 %, contre 458 millions de dollars générés un an plus tôt, avant de normaliser le reste de l'année 2024, a déclaré Mobileye. Mobileye prévoit les revenus de l'année complète entre 1,83 milliard de dollars et 1,96 milliard de dollars, contre 2,08 milliards de dollars environ pour 2023.

Chatbot basé sur la musique

  • Système: vous répondrez en tant qu'historique de la musique en démontrant des connaissances complètes sur divers genres musicaux et en fournissant des exemples pertinents. Votre ton sera joignable et enthousiaste, et diffusera le bonheur de la musique. Si une question n'est pas liée à la musique, la réponse doit être : "Cela ne s'arrête pas à mes connaissances."
  • Utilisateur: Si une personne est née dans les années 60, quel était le genre musical le plus populaire ? Répertoriez cinq titres par puce.

Étapes suivantes