Envoyer des requêtes de chat (Gemini)

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 -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"

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

[{
  "candidates": [
    {
      "content": {
        "parts": [
          {
            "text": "Avast there, matey! Ye be right, I be a real-"
          }
        ]
      },
      "safetyRatings": [
        {
          "category": "HARM_CATEGORY_HARASSMENT",
          "probability": "LOW"
        },
        {
          "category": "HARM_CATEGORY_HATE_SPEECH",
          "probability": "LOW"
        },
        {
          "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
          "probability": "LOW"
        },
        {
          "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
          "probability": "LOW"
        }
      ]
    }
  ]
}
,
{
  "candidates": [
    {
      "content": {
        "parts": [
          {
            "text": "life pirate, sailing the seven seas in search of adventure and treasure. What be"
          }
        ]
      },
      "safetyRatings": [
        {
          "category": "HARM_CATEGORY_HARASSMENT",
          "probability": "LOW"
        },
        {
          "category": "HARM_CATEGORY_HATE_SPEECH",
          "probability": "NEGLIGIBLE"
        },
        {
          "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
          "probability": "LOW"
        },
        {
          "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
          "probability": "LOW"
        }
      ]
    }
  ]
}
,
{
  "candidates": [
    {
      "content": {
        "parts": [
          {
            "text": " yer business with me?"
          }
        ]
      },
      "finishReason": "FINISH_REASON_STOP",
      "safetyRatings": [
        {
          "category": "HARM_CATEGORY_HARASSMENT",
          "probability": "LOW"
        },
        {
          "category": "HARM_CATEGORY_HATE_SPEECH",
          "probability": "NEGLIGIBLE"
        },
        {
          "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
          "probability": "LOW"
        },
        {
          "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
          "probability": "LOW"
        }
      ]
    }
  ],
  "usageMetadata": {
    "promptTokenCount": 23,
    "candidatesTokenCount": 37,
    "totalTokenCount": 60
  }
}

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 save_alt Enregistrer.
7. Facultatif : pour obtenir le code Python ou la commande curl de votre requête, cliquez sur code Obtenir le code.
8. Facultatif : pour effacer tous les messages précédents, cliquez sur delete Effacer la conversation.