Cette page a été traduite par l'API Cloud Translation.

Requêtes "Envoyer une requête multimodale"

La famille de modèles Gemini inclut des modèles qui fonctionnent avec des requêtes d'invites multimodales. Le terme multimodal indique que vous pouvez utiliser plusieurs modalités (ou types d'entrée) dans une requête. Les modèles qui ne sont pas multimodaux n'acceptent que des requêtes textuelles. Les modalités peuvent inclure du texte, de l'audio, de la vidéo, etc…

Il existe plusieurs façons de mettre en œuvre des solutions multimodales à l'aide de l'API Gemini, y compris les SDK Python, Node.js, Java et Go, la console Google Cloud et l'API REST. Les exemples de code plus loin dans le présent document montrent comment créer des solutions multimodales à l'aide de ces options.

Les modèles multimodaux Gemini sont les suivants :

Gemini 1.5 Flash
Gemini 1.5 Pro
Gemini 1.0 Pro Vision

Le tableau suivant indique les modalités avec lesquelles chaque API Gemini multimodale fonctionne dans une requête.

Modèle	Texte	Code	Images	Audio	Vidéo	Vidéo/Audio	PDF
Gemini 1.5 Flash
Gemini 1.5 Pro
Gemini 1.0 Pro Vision
Gemini 1.0 Pro

Pour explorer un modèle multimodal dans la console Google Cloud, sélectionnez sa fiche de modèle dans Model Garden :

Pour obtenir la liste des langues compatibles avec les modèles Gemini, consultez les informations sur les modèles sur la page Langues acceptées. Pour en savoir plus sur la conception de requêtes multimodales, consultez la page Concevoir des requêtes multimodales. Si vous recherchez une méthode pour utiliser Gemini directement à partir de vos applications mobiles et Web, consultez les SDK d'IA de Google pour Android, Swift et le Web.

Différences entre les modèles multimodaux

Les différences entre les modèles multimodaux Gemini sont spécifiées dans les tableaux suivants. Ces informations peuvent vous aider à choisir le modèle qui vous convient le mieux.

Texte

Voici quelques-unes des différences de modalité de texte entre les modèles multimodaux Gemini :

Modèle	Détails de la modalité de texte
Gemini 1.5 Flash, Gemini 1.5 Pro	La longueur du contexte est d'un million de jetons, ce qui équivaut à environ un livre de 4000 pages. Cela permet au modèle de générer du texte long, tel que des livres, plusieurs PDF ou des manuels utilisateur.
Gemini 1.0 Pro Vision	Le nombre maximal de jetons est de 16 384, soit environ un livre de 128 pages (250 mots par page). Cette valeur maximale inclut à la fois les jetons d'entrée et de sortie. Le nombre maximal de jetons de sortie est de 2048.

Code

Voici quelques-unes des différences entre les modèles multimodaux Gemini lorsque vous travaillez avec du code :

Modèle	Détails de la modalité de code
Gemini 1.5 Flash, Gemini 1.5 Pro	La longueur du contexte est d'un million de jetons, ce qui permet au modèle de fonctionner avec l'ensemble d'une codebase ou avec une codebase d'application complète.
Gemini 1.0 Pro Vision	Le nombre maximal de jetons est de 16 384, soit environ un livre de 128 pages (250 mots par page). Cette valeur maximale inclut à la fois les jetons d'entrée et de sortie. Le nombre maximal de jetons de sortie est de 2048.

Images

Voici quelques-unes des différences de modalité d'image entre les modèles multimodaux Gemini :

Modèle	Détails de la modalité d'image
Gemini 1.5 Flash, Gemini 1.5 Pro	Le nombre maximal d'images par requête est de 3000.
Gemini 1.0 Pro Vision	Le nombre maximal d'images par requête est de 16.

Audio (parole uniquement)

Voici quelques-unes des différences de modalité audio entre les modèles multimodaux Gemini :

Modèle	Détails de la modalité audio
Gemini 1.5 Flash, Gemini 1.5 Pro	Le nombre maximal d'heures d'audio par requête est d'environ 8,4 heures, ou jusqu'à un million de jetons. La parole peut être reconnue à des fins de résumé audio, de transcription et de traduction.
Gemini 1.0 Pro Vision	L'audio n'est pas pris en charge.

Vidéo

Voici quelques-unes des différences de modalité vidéo entre les modèles multimodaux Gemini :

Modèle	Détails de la modalité vidéo
Gemini 1.5 Flash, Gemini 1.5 Pro	La durée maximale d'une vidéo, lorsqu'elle inclut du contenu audio, est d'environ 50 minutes. La durée maximale d'une vidéo sans son est d'une heure. Le nombre maximal de vidéos par requête est de 10. Le modèle est capable d'utiliser des données vidéo et audio pour répondre à la requête. Par exemple, il peut résumer une vidéo en utilisant à la fois le contenu visuel et le discours entendu dans la vidéo.
Gemini 1.0 Pro Vision	La durée maximale vidéo est de deux minutes. Le nombre maximal de vidéos par requête est de 1. Le contenu audio de la vidéo est ignoré.

Modèle

Détails de la modalité vidéo

Gemini 1.5 Flash,
Gemini 1.5 Pro

La durée maximale d'une vidéo, lorsqu'elle inclut du contenu audio, est d'environ 50 minutes. La durée maximale d'une vidéo sans son est d'une heure. Le nombre maximal de vidéos par requête est de 10. Le modèle est capable d'utiliser des données vidéo et audio pour répondre à la requête. Par exemple, il peut résumer une vidéo en utilisant à la fois le contenu visuel et le discours entendu dans la vidéo.

Gemini 1.0 Pro Vision

La durée maximale vidéo est de deux minutes. Le nombre maximal de vidéos par requête est de 1. Le contenu audio de la vidéo est ignoré.

PDF

Voici quelques-unes des différences de modalité PDF entre les modèles multimodaux Gemini :

Modèle	Détails de la modalité PDF
Gemini 1.5 Flash, Gemini 1.5 Pro	Le nombre maximal de pages par requête est de 300. La taille maximale d'un fichier PDF est de 30 Mo.
Gemini 1.0 Pro Vision	Le nombre maximal de pages par requête est de 16. La taille maximale d'un fichier PDF est de 30 Mo.

Guide de démarrage rapide

Utilisez les exemples de code suivants pour commencer à utiliser l'API Gemini. Chaque exemple de code illustre l'utilisation d'une modalité différente. Certains exemples de code du présent document fonctionnent avec tous les modèles multimodaux Gemini, et d'autres ne fonctionnent qu'avec Gemini 1.5 Pro. Chaque exemple de code spécifie les modèles avec lesquels il fonctionne.

Pour tester et effectuer des itérations des requêtes multimodales, nous vous recommandons d'utiliser la console Google Cloud. Pour envoyer une requête multimodale par programmation au modèle, vous pouvez utiliser l'API REST, le SDK Vertex AI pour Python, ou l'un des autres SDK ou bibliothèques compatibles présentés dans les onglets suivants :

Image unique

Les exemples de code montrent comment identifier le contenu d'une image.

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, Part

# TODO(developer): Update and un-comment below line
# project_id = "PROJECT_ID"

vertexai.init(project=project_id, location="us-central1")

model = GenerativeModel(model_name="gemini-1.5-flash-001")

image_file = Part.from_uri(
    "gs://cloud-samples-data/generative-ai/image/scones.jpg", "image/jpeg"
)

# Query the model
response = model.generate_content([image_file, "what is this image?"])
print(response.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

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.ContentMaker;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.PartMaker;
import com.google.cloud.vertexai.generativeai.ResponseHandler;
import java.util.Base64;

public class MultimodalQuery {

  public static void main(String[] args) throws Exception {
    // 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-vision-001";
    String dataImageBase64 = "your-base64-encoded-image";

    String output = multimodalQuery(projectId, location, modelName, dataImageBase64);
    System.out.println(output);
  }


  // Ask the model to recognise the brand associated with the logo image.
  public static String multimodalQuery(String projectId, String location, String modelName,
      String dataImageBase64) throws Exception {
    // 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)) {
      String output;
      byte[] imageBytes = Base64.getDecoder().decode(dataImageBase64);

      GenerativeModel model = new GenerativeModel(modelName, vertexAI);
      GenerateContentResponse response = model.generateContent(
          ContentMaker.fromMultiModalData(
              "What is this image?",
              PartMaker.fromMimeTypeAndData("image/png", imageBytes)
          ));

      output = ResponseHandler.getText(response);
      return output;
    }
  }
}

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.

Réponses en streaming et sans streaming

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 createNonStreamingMultipartContent(
  projectId = 'PROJECT_ID',
  location = 'us-central1',
  model = 'gemini-1.5-flash-001',
  image = 'gs://generativeai-downloads/images/scones.jpg',
  mimeType = 'image/jpeg'
) {
  // Initialize Vertex with your Cloud project and location
  const vertexAI = new VertexAI({project: projectId, location: location});

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

  // For images, the SDK supports both Google Cloud Storage URI and base64 strings
  const filePart = {
    fileData: {
      fileUri: image,
      mimeType: mimeType,
    },
  };

  const textPart = {
    text: 'what is shown in this image?',
  };

  const request = {
    contents: [{role: 'user', parts: [filePart, textPart]}],
  };

  console.log('Prompt Text:');
  console.log(request.contents[0].parts[1].text);

  console.log('Non-Streaming Response Text:');
  // Create the response stream
  const responseStream =
    await generativeVisionModel.generateContentStream(request);

  // Wait for the response stream to complete
  const aggregatedResponse = await responseStream.response;

  // Select the text from the response
  const fullTextResponse =
    aggregatedResponse.candidates[0].content.parts[0].text;

  console.log(fullTextResponse);
}

REST

Vous pouvez utiliser REST pour tester une requête textuelle à 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-vision
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 que vous envoyez.
TEXT : instructions textuelles à inclure dans la requête.
B64_BASE : Encodage base64 de l'image, du PDF ou de la vidéo à intégrer à la requête. Lorsque vous intégrez des contenus multimédias, vous devez également spécifier MIMETYPE.
FILE_URI : URI Cloud Storage de l'image ou de la vidéo à inclure dans la requête. Le bucket dans lequel le fichier est stocké doit se trouver dans le projet Google Cloud qui envoie la requête. Vous devez également spécifier MIMETYPE.
MIME_TYPE : type de contenu de l'image, du PDF ou de la vidéo spécifié dans le champ data ou fileUri. Les valeurs acceptées incluent les suivantes :
Cliquer pour développer les types MIME
- application/pdf
- audio/mpeg
- audio/mp3
- audio/wav
- image/png
- image/jpeg
- text/plain
- video/mov
- video/mpeg
- video/mp4
- video/mpg
- video/avi
- video/wmv
- video/mpegps
- video/flv
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.
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": [
      {
        "inlineDATA": {
          "mimeType": "MIME_TYPE",
          "data": "B64_BASE_IMAGE"
        }
      },
      {
        "fileData": {
          "mimeType": "MIME_TYPE",
          "fileUri": "FILE_URI"
        }
      },
      {
        "text": "TEXT"
      }
    ]
  },
  "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

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

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://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.

Réponse

{
  "candidates": [
    {
      "content": {
        "parts": [
          {
            "text": " Yes the animal in the picture is a cat."
          }
        ]
      }
    }
  ],
  "usageMetadata": {
    "promptTokenCount": 263,
    "candidatesTokenCount": 10,
    "totalTokenCount": 273
  }
}

Exemple de commande curl

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

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth application-default 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": [
      {
        "fileData": {
          "mimeType": "image/png",
          "fileUri": "gs://my-bucket/images/cat.png"
        }
      },
      {
        "text": "Describe this picture."
      },
    ]
  },
  "safety_settings": {
    "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
    "threshold": "BLOCK_LOW_AND_ABOVE"
  },
  "generation_config": {
    "temperature": 0.4,
    "topP": 1,
    "topK": 32,
    "maxOutputTokens": 2048,
  }
}'

Console

Pour envoyer une requête multimodale à l'aide de 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
Sous Prompt design (single turn) (Conception de requête (un seul tour)), cliquez sur Ouvrir.
Configurez le modèle et les paramètres :
- Modèle: sélectionnez un modèle.
- Région : sélectionnez la région que vous souhaitez utiliser.
- 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.
Facultatif : pour configurer des 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.
Enable Grounding (Activer l'ancrage) : si cette option est activée, elle fournit des réponses factuelles du modèle. L'ancrage n'accepte que les entrées de texte et la sortie de texte. Pour en savoir plus, consultez la page Présentation de l'ancrage.

Sélectionnez Activer l'ancrage.
Cliquez sur Personnaliser.
Spécifiez la source et le chemin d'ancrage.
Cliquez sur Enregistrer.

Réponses en streaming: cette option n'est pas activée. 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.

Pour importer des fichiers multimédias tels que des fichiers PDF, MP4, WAV et JPG, procédez comme suit :

Saisissez votre requête textuelle dans le volet Requête. Le modèle utilise les messages précédents comme contexte pour les nouvelles réponses.
Cliquez sur Insérer un média, puis sélectionnez une source. Si vous choisissez Google Drive comme source, vous devez sélectionner un compte et autoriser Vertex AI Studio à accéder à votre compte la première fois que vous sélectionnez cette option. Pour importer plusieurs fichiers, répétez cette étape. Vous pouvez importer plusieurs images dont la taille totale est de 10 Mo. La taille d'un fichier ne peut pas dépasser 7 Mo.
Accédez au fichier que vous souhaitez importer, cliquez dessus, puis cliquez sur Sélectionner. La vignette du fichier s'affiche dans le volet Requête.
Cliquez sur Envoyer pour générer la réponse.

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 Obtenir le code.
Facultatif : pour effacer tous les messages précédents, cliquez sur Effacer la conversation.

PDF unique

Les exemples de code montrent comment inclure un fichier PDF dans une requête à l'aide du SDK Vertex AI pour Python.

Python

Réponses en streaming et sans streaming

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, Part

# TODO(developer): Update and un-comment below lines
# project_id = "PROJECT_ID"

vertexai.init(project=project_id, location="us-central1")

model = GenerativeModel(model_name="gemini-1.5-flash-001")

prompt = """
You are a very professional document summarization specialist.
Please summarize the given document.
"""

pdf_file_uri = "gs://cloud-samples-data/generative-ai/pdf/2403.05530.pdf"
pdf_file = Part.from_uri(pdf_file_uri, mime_type="application/pdf")
contents = [pdf_file, prompt]

response = model.generate_content(contents)
print(response.text)

Java

Réponses en streaming et sans streaming

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.ContentMaker;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.PartMaker;
import com.google.cloud.vertexai.generativeai.ResponseHandler;
import java.io.IOException;

public class PdfInput {

  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.5-flash-001";

    pdfInput(projectId, location, modelName);
  }

  // Analyzes the given video input.
  public static String pdfInput(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)) {
      String pdfUri = "gs://cloud-samples-data/generative-ai/pdf/2403.05530.pdf";

      GenerativeModel model = new GenerativeModel(modelName, vertexAI);
      GenerateContentResponse response = model.generateContent(
          ContentMaker.fromMultiModalData(
              "You are a very professional document summarization specialist.\n"
                  + "Please summarize the given document.",
              PartMaker.fromMimeTypeAndData("application/pdf", pdfUri)
          ));

      String output = ResponseHandler.getText(response);
      System.out.println(output);
      return output;
    }
  }
}

Node.js

Réponses en streaming et sans streaming

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 analyze_pdf(projectId = 'PROJECT_ID') {
  const vertexAI = new VertexAI({project: projectId, location: 'us-central1'});

  const generativeModel = vertexAI.getGenerativeModel({
    model: 'gemini-1.5-pro-preview-0409',
  });

  const filePart = {
    file_data: {
      file_uri: 'gs://cloud-samples-data/generative-ai/pdf/2403.05530.pdf',
      mime_type: 'application/pdf',
    },
  };
  const textPart = {
    text: `
    You are a very professional document summarization specialist.
    Please summarize the given document.`,
  };

  const request = {
    contents: [{role: 'user', parts: [filePart, textPart]}],
  };

  const resp = await generativeModel.generateContent(request);
  const contentResponse = await resp.response;
  console.log(JSON.stringify(contentResponse));
}

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.Threading.Tasks;

public class PdfInput
{
    public async Task<string> SummarizePdf(
        string projectId = "your-project-id",
        string location = "us-central1",
        string publisher = "google",
        string model = "gemini-1.5-flash-001")
    {

        var predictionServiceClient = new PredictionServiceClientBuilder
        {
            Endpoint = $"{location}-aiplatform.googleapis.com"
        }.Build();

        string prompt = @"You are a very professional document summarization specialist.
Please summarize the given document.";

        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { Text = prompt },
                        new Part { FileData = new() { MimeType = "application/pdf", FileUri = "gs://cloud-samples-data/generative-ai/pdf/2403.05530.pdf" }}
                    }
                }
            }
        };

        GenerateContentResponse response = await predictionServiceClient.GenerateContentAsync(generateContentRequest);

        string responseText = response.Candidates[0].Content.Parts[0].Text;
        Console.WriteLine(responseText);

        return responseText;
    }
}

Console

Pour envoyer une requête multimodale à l'aide de 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
Sous Prompt design (single turn) (Conception de requête (un seul tour)), cliquez sur Ouvrir.
Configurez le modèle et les paramètres :
- Modèle: sélectionnez un modèle.
- Région : sélectionnez la région que vous souhaitez utiliser.
- 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.
Facultatif : pour configurer des 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.
Enable Grounding (Activer l'ancrage) : si cette option est activée, elle fournit des réponses factuelles du modèle. L'ancrage n'accepte que les entrées de texte et la sortie de texte. Pour en savoir plus, consultez la page Présentation de l'ancrage.

Sélectionnez Activer l'ancrage.
Cliquez sur Personnaliser.
Spécifiez la source et le chemin d'ancrage.
Cliquez sur Enregistrer.

Réponses en streaming: cette option n'est pas activée. 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.

Pour importer des fichiers multimédias tels que des fichiers PDF, MP4, WAV et JPG, procédez comme suit :

Saisissez votre requête textuelle dans le volet Requête. Le modèle utilise les messages précédents comme contexte pour les nouvelles réponses.
Cliquez sur Insérer un média, puis sélectionnez une source. Si vous choisissez Google Drive comme source, vous devez sélectionner un compte et autoriser Vertex AI Studio à accéder à votre compte la première fois que vous sélectionnez cette option. Pour importer plusieurs fichiers, répétez cette étape. Vous pouvez importer plusieurs images dont la taille totale est de 10 Mo. La taille d'un fichier ne peut pas dépasser 7 Mo.
Accédez au fichier que vous souhaitez importer, cliquez dessus, puis cliquez sur Sélectionner. La vignette du fichier s'affiche dans le volet Requête.
Cliquez sur Envoyer pour générer la réponse.

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 Obtenir le code.
Facultatif : pour effacer tous les messages précédents, cliquez sur Effacer la conversation.

Vidéo unique

Les exemples de code montrent comment inclure une vidéo dans une requête de demande.

Python

Réponses en streaming et sans streaming

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, Part

# TODO(developer): Update and un-comment below line
# project_id = "PROJECT_ID"

vertexai.init(project=project_id, location="us-central1")

vision_model = GenerativeModel(model_name="gemini-1.5-flash-001")

# Generate text
response = vision_model.generate_content(
    [
        Part.from_uri(
            "gs://cloud-samples-data/video/animals.mp4", mime_type="video/mp4"
        ),
        "What is in the video?",
    ]
)
print(response.text)

Java

Réponses en streaming et sans streaming

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.ContentMaker;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.PartMaker;
import com.google.cloud.vertexai.generativeai.ResponseHandler;
import java.io.IOException;

public class MultimodalVideoInput {

  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.5-flash-001";

    multimodalVideoInput(projectId, location, modelName);
  }

  // Analyzes the given video input.
  public static void multimodalVideoInput(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)) {
      String videoUri = "gs://cloud-samples-data/video/animals.mp4";

      GenerativeModel model = new GenerativeModel(modelName, vertexAI);
      GenerateContentResponse response = model.generateContent(
          ContentMaker.fromMultiModalData(
              "What is in the video?",
              PartMaker.fromMimeTypeAndData("video/mp4", videoUri)
          ));

      String output = ResponseHandler.getText(response);
      System.out.println(output);
    }
  }
}

Node.js

Réponses en streaming et sans streaming

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 sendMultiModalPromptWithVideo(
  projectId = 'PROJECT_ID',
  location = 'us-central1',
  model = 'gemini-1.0-pro-vision-001'
) {
  // Initialize Vertex with your Cloud project and location
  const vertexAI = new VertexAI({project: projectId, location: location});

  const generativeVisionModel = vertexAI.getGenerativeModel({
    model: model,
  });

  // Pass multimodal prompt
  const request = {
    contents: [
      {
        role: 'user',
        parts: [
          {
            fileData: {
              fileUri: 'gs://cloud-samples-data/video/animals.mp4',
              mimeType: 'video/mp4',
            },
          },
          {
            text: 'What is in the video?',
          },
        ],
      },
    ],
  };

  // Create the response
  const response = await generativeVisionModel.generateContent(request);
  // Wait for the response to complete
  const aggregatedResponse = await response.response;
  // Select the text from the response
  const fullTextResponse =
    aggregatedResponse.candidates[0].content.parts[0].text;

  console.log(fullTextResponse);
}

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.

Réponses en streaming et sans streaming

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"
	"errors"
	"fmt"
	"io"
	"mime"
	"path/filepath"

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

// generateMultimodalContent generates a response into w, based upon the prompt
// and video provided.
// video is a Google Cloud Storage path starting with "gs://"
func generateMultimodalContent(w io.Writer, prompt, video, projectID, location, modelName string) error {
	// prompt := "What is in this video?"
	// video := "gs://cloud-samples-data/video/animals.mp4"
	// location := "us-central1"
	// modelName := "gemini-1.0-pro-vision-001"
	ctx := context.Background()

	client, err := genai.NewClient(ctx, projectID, location)
	if err != nil {
		return fmt.Errorf("unable to create client: %v", err)
	}
	defer client.Close()

	model := client.GenerativeModel(modelName)
	model.SetTemperature(0.4)

	// Given a video file URL, prepare video file as genai.Part
	part := genai.FileData{
		MIMEType: mime.TypeByExtension(filepath.Ext(video)),
		FileURI:  video,
	}

	res, err := model.GenerateContent(ctx, part, genai.Text(prompt))
	if err != nil {
		return fmt.Errorf("unable to generate contents: %v", err)
	}

	if len(res.Candidates) == 0 ||
		len(res.Candidates[0].Content.Parts) == 0 {
		return errors.New("empty response from model")
	}

	fmt.Fprintf(w, "generated response: %s\n", res.Candidates[0].Content.Parts[0])
	return nil
}

C#


using Google.Api.Gax.Grpc;
using Google.Cloud.AIPlatform.V1;
using System.Text;
using System.Threading.Tasks;

public class MultimodalVideoInput
{
    public async Task<string> GenerateContent(
        string projectId = "your-project-id",
        string location = "us-central1",
        string publisher = "google",
        string model = "gemini-1.0-pro-vision"
    )
    {
        var predictionServiceClient = new PredictionServiceClientBuilder
        {
            Endpoint = $"{location}-aiplatform.googleapis.com"
        }.Build();

        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { Text = "What's in the video?" },
                        new Part { FileData = new() { MimeType = "video/mp4", FileUri = "gs://cloud-samples-data/video/animals.mp4" }}
                    }
                }
            }
        };

        using PredictionServiceClient.StreamGenerateContentStream response = predictionServiceClient.StreamGenerateContent(generateContentRequest);

        StringBuilder fullText = new();

        AsyncResponseStream<GenerateContentResponse> responseStream = response.GetResponseStream();
        await foreach (GenerateContentResponse responseItem in responseStream)
        {
            fullText.Append(responseItem.Candidates[0].Content.Parts[0].Text);
        }
        return fullText.ToString();
    }
}

REST

Vous pouvez utiliser REST pour tester une requête textuelle à 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-vision
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 que vous envoyez.
TEXT : instructions textuelles à inclure dans la requête.
B64_BASE : Encodage base64 de l'image, du PDF ou de la vidéo à intégrer à la requête. Lorsque vous intégrez des contenus multimédias, vous devez également spécifier MIMETYPE.
FILE_URI : URI Cloud Storage de l'image ou de la vidéo à inclure dans la requête. Le bucket dans lequel le fichier est stocké doit se trouver dans le projet Google Cloud qui envoie la requête. Vous devez également spécifier MIMETYPE.
MIME_TYPE : type de contenu de l'image, du PDF ou de la vidéo spécifié dans le champ data ou fileUri. Les valeurs acceptées incluent les suivantes :
Cliquer pour développer les types MIME
- application/pdf
- audio/mpeg
- audio/mp3
- audio/wav
- image/png
- image/jpeg
- text/plain
- video/mov
- video/mpeg
- video/mp4
- video/mpg
- video/avi
- video/wmv
- video/mpegps
- video/flv
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.
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": [
      {
        "inlineDATA": {
          "mimeType": "MIME_TYPE",
          "data": "B64_BASE_IMAGE"
        }
      },
      {
        "fileData": {
          "mimeType": "MIME_TYPE",
          "fileUri": "FILE_URI"
        }
      },
      {
        "text": "TEXT"
      }
    ]
  },
  "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

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://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.

Réponse

{
  "candidates": [
    {
      "content": {
        "parts": [
          {
            "text": " Yes the animal in the picture is a cat."
          }
        ]
      }
    }
  ],
  "usageMetadata": {
    "promptTokenCount": 263,
    "candidatesTokenCount": 10,
    "totalTokenCount": 273
  }
}

Exemple de commande curl

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

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth application-default 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": [
      {
        "fileData": {
          "mimeType": "image/png",
          "fileUri": "gs://my-bucket/images/cat.png"
        }
      },
      {
        "text": "Describe this picture."
      },
    ]
  },
  "safety_settings": {
    "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
    "threshold": "BLOCK_LOW_AND_ABOVE"
  },
  "generation_config": {
    "temperature": 0.4,
    "topP": 1,
    "topK": 32,
    "maxOutputTokens": 2048,
  }
}'

Console

Pour envoyer une requête multimodale à l'aide de 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
Sous Prompt design (single turn) (Conception de requête (un seul tour)), cliquez sur Ouvrir.
Configurez le modèle et les paramètres :
- Modèle: sélectionnez un modèle.
- Région : sélectionnez la région que vous souhaitez utiliser.
- 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.
Facultatif : pour configurer des 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.
Enable Grounding (Activer l'ancrage) : si cette option est activée, elle fournit des réponses factuelles du modèle. L'ancrage n'accepte que les entrées de texte et la sortie de texte. Pour en savoir plus, consultez la page Présentation de l'ancrage.

Sélectionnez Activer l'ancrage.
Cliquez sur Personnaliser.
Spécifiez la source et le chemin d'ancrage.
Cliquez sur Enregistrer.

Réponses en streaming: cette option n'est pas activée. 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.

Pour importer des fichiers multimédias tels que des fichiers PDF, MP4, WAV et JPG, procédez comme suit :

Saisissez votre requête textuelle dans le volet Requête. Le modèle utilise les messages précédents comme contexte pour les nouvelles réponses.
Cliquez sur Insérer un média, puis sélectionnez une source. Si vous choisissez Google Drive comme source, vous devez sélectionner un compte et autoriser Vertex AI Studio à accéder à votre compte la première fois que vous sélectionnez cette option. Pour importer plusieurs fichiers, répétez cette étape. Vous pouvez importer plusieurs images dont la taille totale est de 10 Mo. La taille d'un fichier ne peut pas dépasser 7 Mo.
Accédez au fichier que vous souhaitez importer, cliquez dessus, puis cliquez sur Sélectionner. La vignette du fichier s'affiche dans le volet Requête.
Cliquez sur Envoyer pour générer la réponse.

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 Obtenir le code.
Facultatif : pour effacer tous les messages précédents, cliquez sur Effacer la conversation.

Audio unique

Les exemples de code montrent comment utiliser un fichier audio pour résumer un podcast. Cet exemple ne fonctionne qu'avec Gemini 1.5 Pro.

Python

Réponses en streaming et sans streaming

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, Part

  # TODO(developer): Update and un-comment below lines
  # project_id = "PROJECT_ID"

  vertexai.init(project=project_id, location="us-central1")

  model = GenerativeModel(model_name="gemini-1.5-flash-001")

  prompt = """
  Please provide a summary for the audio.
  Provide chapter titles, be concise and short, no need to provide chapter summaries.
  Do not make up any information that is not part of the audio and do not be verbose.
"""

  audio_file_uri = "gs://cloud-samples-data/generative-ai/audio/pixel.mp3"
  audio_file = Part.from_uri(audio_file_uri, mime_type="audio/mpeg")

  contents = [audio_file, prompt]

  response = model.generate_content(contents)
  print(response.text)

Console

Pour envoyer une requête multimodale à l'aide de 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
Sous Prompt design (single turn) (Conception de requête (un seul tour)), cliquez sur Ouvrir.
Configurez le modèle et les paramètres :
- Modèle: sélectionnez un modèle.
- Région : sélectionnez la région que vous souhaitez utiliser.
- 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.
Facultatif : pour configurer des 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.
Enable Grounding (Activer l'ancrage) : si cette option est activée, elle fournit des réponses factuelles du modèle. L'ancrage n'accepte que les entrées de texte et la sortie de texte. Pour en savoir plus, consultez la page Présentation de l'ancrage.

Sélectionnez Activer l'ancrage.
Cliquez sur Personnaliser.
Spécifiez la source et le chemin d'ancrage.
Cliquez sur Enregistrer.

Réponses en streaming: cette option n'est pas activée. 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.

Pour importer des fichiers multimédias tels que des fichiers PDF, MP4, WAV et JPG, procédez comme suit :

Saisissez votre requête textuelle dans le volet Requête. Le modèle utilise les messages précédents comme contexte pour les nouvelles réponses.
Cliquez sur Insérer un média, puis sélectionnez une source. Si vous choisissez Google Drive comme source, vous devez sélectionner un compte et autoriser Vertex AI Studio à accéder à votre compte la première fois que vous sélectionnez cette option. Pour importer plusieurs fichiers, répétez cette étape. Vous pouvez importer plusieurs images dont la taille totale est de 10 Mo. La taille d'un fichier ne peut pas dépasser 7 Mo.
Accédez au fichier que vous souhaitez importer, cliquez dessus, puis cliquez sur Sélectionner. La vignette du fichier s'affiche dans le volet Requête.
Cliquez sur Envoyer pour générer la réponse.

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 Obtenir le code.
Facultatif : pour effacer tous les messages précédents, cliquez sur Effacer la conversation.

Exemples avancés

Les exemples suivants sont plus complexes que les exemples précédents.

Images multiples

Les exemples de code montrent comment inclure plusieurs images dans une requête de demande.

Python

Réponses en streaming et sans streaming

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, Part

# TODO(developer): Update and un-comment below line
# project_id = "PROJECT_ID"

vertexai.init(project=project_id, location="us-central1")

# Load images from Cloud Storage URI
image_file1 = Part.from_uri(
    "gs://cloud-samples-data/vertex-ai/llm/prompts/landmark1.png",
    mime_type="image/png",
)
image_file2 = Part.from_uri(
    "gs://cloud-samples-data/vertex-ai/llm/prompts/landmark2.png",
    mime_type="image/png",
)
image_file3 = Part.from_uri(
    "gs://cloud-samples-data/vertex-ai/llm/prompts/landmark3.png",
    mime_type="image/png",
)

model = GenerativeModel(model_name="gemini-1.5-flash-001")
response = model.generate_content(
    [
        image_file1,
        "city: Rome, Landmark: the Colosseum",
        image_file2,
        "city: Beijing, Landmark: Forbidden City",
        image_file3,
    ]
)
print(response.text)

Java

Réponses en streaming et sans streaming

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.Content;
import com.google.cloud.vertexai.api.GenerateContentResponse;
import com.google.cloud.vertexai.generativeai.ContentMaker;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.PartMaker;
import com.google.cloud.vertexai.generativeai.ResponseHandler;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class MultimodalMultiImage {

  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-vision-001";

    multimodalMultiImage(projectId, location, modelName);
  }

  // Generates content from multiple input images.
  public static void multimodalMultiImage(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)) {
      GenerativeModel model = new GenerativeModel(modelName, vertexAI);

      Content content = ContentMaker.fromMultiModalData(
          PartMaker.fromMimeTypeAndData("image/png", readImageFile(
              "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark1.png")),
          "city: Rome, Landmark: the Colosseum",
          PartMaker.fromMimeTypeAndData("image/png", readImageFile(
              "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark2.png")),
          "city: Beijing, Landmark: Forbidden City",
          PartMaker.fromMimeTypeAndData("image/png", readImageFile(
              "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark3.png"))
      );

      GenerateContentResponse response = model.generateContent(content);

      String output = ResponseHandler.getText(response);
      System.out.println(output);
    }
  }

  // Reads the image data from the given URL.
  public static byte[] readImageFile(String url) throws IOException {
    URL urlObj = new URL(url);
    HttpURLConnection connection = (HttpURLConnection) urlObj.openConnection();
    connection.setRequestMethod("GET");

    int responseCode = connection.getResponseCode();

    if (responseCode == HttpURLConnection.HTTP_OK) {
      InputStream inputStream = connection.getInputStream();
      ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

      byte[] buffer = new byte[1024];
      int bytesRead;
      while ((bytesRead = inputStream.read(buffer)) != -1) {
        outputStream.write(buffer, 0, bytesRead);
      }

      return outputStream.toByteArray();
    } else {
      throw new RuntimeException("Error fetching file: " + responseCode);
    }
  }
}

Node.js

Réponses en streaming et sans streaming

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');
const axios = require('axios');

async function getBase64(url) {
  const image = await axios.get(url, {responseType: 'arraybuffer'});
  return Buffer.from(image.data).toString('base64');
}

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function sendMultiModalPromptWithImage(
  projectId = 'PROJECT_ID',
  location = 'us-central1',
  model = 'gemini-1.0-pro-vision-001'
) {
  // For images, the SDK supports base64 strings
  const landmarkImage1 = await getBase64(
    'https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark1.png'
  );
  const landmarkImage2 = await getBase64(
    'https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark2.png'
  );
  const landmarkImage3 = await getBase64(
    'https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark3.png'
  );

  // Initialize Vertex with your Cloud project and location
  const vertexAI = new VertexAI({project: projectId, location: location});

  const generativeVisionModel = vertexAI.getGenerativeModel({
    model: model,
  });

  // Pass multimodal prompt
  const request = {
    contents: [
      {
        role: 'user',
        parts: [
          {
            inlineData: {
              data: landmarkImage1,
              mimeType: 'image/png',
            },
          },
          {
            text: 'city: Rome, Landmark: the Colosseum',
          },

          {
            inlineData: {
              data: landmarkImage2,
              mimeType: 'image/png',
            },
          },
          {
            text: 'city: Beijing, Landmark: Forbidden City',
          },
          {
            inlineData: {
              data: landmarkImage3,
              mimeType: 'image/png',
            },
          },
        ],
      },
    ],
  };

  // Create the response
  const response = await generativeVisionModel.generateContent(request);
  // Wait for the response to complete
  const aggregatedResponse = await response.response;
  // Select the text from the response
  const fullTextResponse =
    aggregatedResponse.candidates[0].content.parts[0].text;

  console.log(fullTextResponse);
}

Go

Réponses en streaming et sans streaming

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"
	"fmt"
	"io"
	"log"
	"net/http"
	"net/url"
	"os"
	"strings"

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

func main() {
	projectID := os.Getenv("GOOGLE_CLOUD_PROJECT")
	location := "us-central1"
	modelName := "gemini-1.0-pro-vision"
	temperature := 0.4

	if projectID == "" {
		log.Fatal("require environment variable GOOGLE_CLOUD_PROJECT")
	}

	// construct this multimodal prompt:
	// [image of colosseum] city: Rome, Landmark: the Colosseum
	// [image of forbidden city]  city: Beijing, Landmark: the Forbidden City
	// [new image]

	// create prompt image parts
	// colosseum
	colosseum, err := partFromImageURL("https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark1.png")
	if err != nil {
		log.Fatalf("unable to read image: %v", err)
	}
	// forbidden city
	forbiddenCity, err := partFromImageURL("https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark2.png")
	if err != nil {
		log.Fatalf("unable to read image: %v", err)
	}
	// new image
	newImage, err := partFromImageURL("https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark3.png")
	if err != nil {
		log.Fatalf("unable to read image: %v", err)
	}

	// create a multimodal (multipart) prompt
	prompt := []genai.Part{
		colosseum,
		genai.Text("city: Rome, Landmark: the Colosseum "),
		forbiddenCity,
		genai.Text("city: Beijing, Landmark: the Forbidden City "),
		newImage,
	}

	// generate the response
	err = generateMultimodalContent(os.Stdout, prompt, projectID, location, modelName, float32(temperature))
	if err != nil {
		log.Fatalf("unable to generate: %v", err)
	}
}

// generateMultimodalContent provide a generated response using multimodal input
func generateMultimodalContent(w io.Writer, parts []genai.Part, projectID, location, modelName string, temperature float32) error {
	ctx := context.Background()

	client, err := genai.NewClient(ctx, projectID, location)
	if err != nil {
		log.Fatal(err)
	}
	defer client.Close()

	model := client.GenerativeModel(modelName)
	model.SetTemperature(temperature)

	res, err := model.GenerateContent(ctx, parts...)
	if err != nil {
		return fmt.Errorf("unable to generate contents: %v", err)
	}

	fmt.Fprintf(w, "generated response: %s\n", res.Candidates[0].Content.Parts[0])

	return nil
}

// partFromImageURL create a multimodal prompt part from an image URL
func partFromImageURL(image string) (genai.Part, error) {
	var img genai.Blob

	imageURL, err := url.Parse(image)
	if err != nil {
		return img, err
	}
	res, err := http.Get(image)
	if err != nil || res.StatusCode != 200 {
		return img, err
	}
	defer res.Body.Close()
	data, err := io.ReadAll(res.Body)
	if err != nil {
		return img, fmt.Errorf("unable to read from http: %v", err)
	}

	position := strings.LastIndex(imageURL.Path, ".")
	if position == -1 {
		return img, fmt.Errorf("couldn't find a period to indicate a file extension")
	}
	ext := imageURL.Path[position+1:]

	img = genai.ImageData(ext, data)
	return img, nil
}

C#


using Google.Api.Gax.Grpc;
using Google.Cloud.AIPlatform.V1;
using Google.Protobuf;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

public class MultimodalMultiImage
{
    public async Task<string> GenerateContent(
        string projectId = "your-project-id",
        string location = "us-central1",
        string publisher = "google",
        string model = "gemini-1.0-pro-vision"
    )
    {
        var predictionServiceClient = new PredictionServiceClientBuilder
        {
            Endpoint = $"{location}-aiplatform.googleapis.com"
        }.Build();

        ByteString colosseum = await ReadImageFileAsync(
            "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark1.png");

        ByteString forbiddenCity = await ReadImageFileAsync(
            "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark2.png");

        ByteString christRedeemer = await ReadImageFileAsync(
            "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark3.png");

        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { InlineData = new() { MimeType = "image/png", Data = colosseum }},
                        new Part { Text = "city: Rome, Landmark: the Colosseum" },
                        new Part { InlineData = new() { MimeType = "image/png", Data = forbiddenCity }},
                        new Part { Text = "city: Beijing, Landmark: Forbidden City"},
                        new Part { InlineData = new() { MimeType = "image/png", Data = christRedeemer }}
                    }
                }
            }
        };

        using PredictionServiceClient.StreamGenerateContentStream response = predictionServiceClient.StreamGenerateContent(generateContentRequest);

        StringBuilder fullText = new();

        AsyncResponseStream<GenerateContentResponse> responseStream = response.GetResponseStream();
        await foreach (GenerateContentResponse responseItem in responseStream)
        {
            fullText.Append(responseItem.Candidates[0].Content.Parts[0].Text);
        }
        return fullText.ToString();
    }

    private static async Task<ByteString> ReadImageFileAsync(string url)
    {
        using HttpClient client = new();
        using var response = await client.GetAsync(url);
        byte[] imageBytes = await response.Content.ReadAsByteArrayAsync();
        return ByteString.CopyFrom(imageBytes);
    }
}

REST

Vous pouvez utiliser REST pour tester une requête textuelle à 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-vision
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 que vous envoyez.
TEXT : instructions textuelles à inclure dans la requête.
B64_BASE : Encodage base64 de l'image, du PDF ou de la vidéo à intégrer à la requête. Lorsque vous intégrez des contenus multimédias, vous devez également spécifier MIMETYPE.
FILE_URI : URI Cloud Storage de l'image ou de la vidéo à inclure dans la requête. Le bucket dans lequel le fichier est stocké doit se trouver dans le projet Google Cloud qui envoie la requête. Vous devez également spécifier MIMETYPE.
MIME_TYPE : type de contenu de l'image, du PDF ou de la vidéo spécifié dans le champ data ou fileUri. Les valeurs acceptées incluent les suivantes :
Cliquer pour développer les types MIME
- application/pdf
- audio/mpeg
- audio/mp3
- audio/wav
- image/png
- image/jpeg
- text/plain
- video/mov
- video/mpeg
- video/mp4
- video/mpg
- video/avi
- video/wmv
- video/mpegps
- video/flv
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.
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": [
      {
        "inlineDATA": {
          "mimeType": "MIME_TYPE",
          "data": "B64_BASE_IMAGE"
        }
      },
      {
        "fileData": {
          "mimeType": "MIME_TYPE",
          "fileUri": "FILE_URI"
        }
      },
      {
        "text": "TEXT"
      }
    ]
  },
  "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

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://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.

Réponse

{
  "candidates": [
    {
      "content": {
        "parts": [
          {
            "text": " Yes the animal in the picture is a cat."
          }
        ]
      }
    }
  ],
  "usageMetadata": {
    "promptTokenCount": 263,
    "candidatesTokenCount": 10,
    "totalTokenCount": 273
  }
}

Exemple de commande curl

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

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth application-default 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": [
      {
        "fileData": {
          "mimeType": "image/png",
          "fileUri": "gs://my-bucket/images/cat.png"
        }
      },
      {
        "text": "Describe this picture."
      },
    ]
  },
  "safety_settings": {
    "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
    "threshold": "BLOCK_LOW_AND_ABOVE"
  },
  "generation_config": {
    "temperature": 0.4,
    "topP": 1,
    "topK": 32,
    "maxOutputTokens": 2048,
  }
}'

Console

Pour envoyer une requête multimodale à l'aide de 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
Sous Prompt design (single turn) (Conception de requête (un seul tour)), cliquez sur Ouvrir.
Configurez le modèle et les paramètres :
- Modèle: sélectionnez un modèle.
- Région : sélectionnez la région que vous souhaitez utiliser.
- 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.
Facultatif : pour configurer des 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.
Enable Grounding (Activer l'ancrage) : si cette option est activée, elle fournit des réponses factuelles du modèle. L'ancrage n'accepte que les entrées de texte et la sortie de texte. Pour en savoir plus, consultez la page Présentation de l'ancrage.

Sélectionnez Activer l'ancrage.
Cliquez sur Personnaliser.
Spécifiez la source et le chemin d'ancrage.
Cliquez sur Enregistrer.

Réponses en streaming: cette option n'est pas activée. 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.

Pour importer des fichiers multimédias tels que des fichiers PDF, MP4, WAV et JPG, procédez comme suit :

Saisissez votre requête textuelle dans le volet Requête. Le modèle utilise les messages précédents comme contexte pour les nouvelles réponses.
Cliquez sur Insérer un média, puis sélectionnez une source. Si vous choisissez Google Drive comme source, vous devez sélectionner un compte et autoriser Vertex AI Studio à accéder à votre compte la première fois que vous sélectionnez cette option. Pour importer plusieurs fichiers, répétez cette étape. Vous pouvez importer plusieurs images dont la taille totale est de 10 Mo. La taille d'un fichier ne peut pas dépasser 7 Mo.
Accédez au fichier que vous souhaitez importer, cliquez dessus, puis cliquez sur Sélectionner. La vignette du fichier s'affiche dans le volet Requête.
Cliquez sur Envoyer pour générer la réponse.

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 Obtenir le code.
Facultatif : pour effacer tous les messages précédents, cliquez sur Effacer la conversation.

Transcription audio

Les exemples de code montrent comment utiliser un fichier audio pour transcrire un entretien. Cet exemple ne fonctionne qu'avec Gemini 1.5 Pro.

Go

Réponses en streaming et sans streaming

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"
	"errors"
	"fmt"
	"io"
	"mime"
	"path/filepath"

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

// audioPrompt is a sample prompt type consisting of one audio asset, and a text question.
type audioPrompt struct {
	// audio is a Google Cloud Storage path starting with "gs://"
	audio string
	// question asked to the model
	question string
}

// transcribeAudio generates a response into w, based upon the prompt
// and audio provided.
// audio is a Google Cloud Storage path starting with "gs://"
func transcribeAudio(w io.Writer, prompt audioPrompt, projectID, location, modelName string) error {
	// prompt := audioPrompt{
	// 	audio: "gs://cloud-samples-data/generative-ai/audio/pixel.mp3",
	// 	question: `
	// 		Can you transcribe this interview, in the format of timecode, speaker, caption.
	// 		Use speaker A, speaker B, etc. to identify speakers.
	// 	`,
	// },
	// location := "us-central1"
	// modelName := "gemini-1.5-pro-preview-0409"
	ctx := context.Background()

	client, err := genai.NewClient(ctx, projectID, location)
	if err != nil {
		return fmt.Errorf("unable to create client: %w", err)
	}
	defer client.Close()

	model := client.GenerativeModel(modelName)

	// Optional: set an explicit temperature
	model.SetTemperature(0.4)

	// Given an audio file URL, prepare audio file as genai.Part
	img := genai.FileData{
		MIMEType: mime.TypeByExtension(filepath.Ext(prompt.audio)),
		FileURI:  prompt.audio,
	}

	res, err := model.GenerateContent(ctx, img, genai.Text(prompt.question))
	if err != nil {
		return fmt.Errorf("unable to generate contents: %w", err)
	}

	if len(res.Candidates) == 0 ||
		len(res.Candidates[0].Content.Parts) == 0 {
		return errors.New("empty response from model")
	}

	fmt.Fprintf(w, "generated transcript:\n%s\n", res.Candidates[0].Content.Parts[0])
	return nil
}

C#


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

public class AudioInputTranscription
{
    public async Task<string> TranscribeAudio(
        string projectId = "your-project-id",
        string location = "us-central1",
        string publisher = "google",
        string model = "gemini-1.5-flash-001")
    {

        var predictionServiceClient = new PredictionServiceClientBuilder
        {
            Endpoint = $"{location}-aiplatform.googleapis.com"
        }.Build();

        string prompt = @"Can you transcribe this interview, in the format of timecode, speaker, caption.
Use speaker A, speaker B, etc. to identify speakers.";

        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { Text = prompt },
                        new Part { FileData = new() { MimeType = "audio/mp3", FileUri = "gs://cloud-samples-data/generative-ai/audio/pixel.mp3" } }
                    }
                }
            }
        };

        GenerateContentResponse response = await predictionServiceClient.GenerateContentAsync(generateContentRequest);

        string responseText = response.Candidates[0].Content.Parts[0].Text;
        Console.WriteLine(responseText);

        return responseText;
    }
}

Vidéo avec audio

Les exemples de code montrent comment résumer un fichier vidéo avec audio. Les exemples de code renvoient également des chapitres avec des horodatages. Ces exemples ne fonctionnent qu'avec Gemini 1.5 Pro.

Python

Réponses en streaming et sans streaming

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, Part

# TODO(developer): Update and un-comment below lines
# project_id = "PROJECT_ID"

vertexai.init(project=project_id, location="us-central1")

model = GenerativeModel(model_name="gemini-1.5-flash-001")

prompt = """
Provide a description of the video.
The description should also contain anything important which people say in the video.
"""

video_file_uri = "gs://cloud-samples-data/generative-ai/video/pixel8.mp4"
video_file = Part.from_uri(video_file_uri, mime_type="video/mp4")

contents = [video_file, prompt]

response = model.generate_content(contents)
print(response.text)

Java

Réponses en streaming et sans streaming

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.ContentMaker;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.PartMaker;
import com.google.cloud.vertexai.generativeai.ResponseHandler;
import java.io.IOException;

public class VideoInputWithAudio {

  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.5-flash-001";

    videoAudioInput(projectId, location, modelName);
  }

  // Analyzes the given video input, including its audio track.
  public static String videoAudioInput(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)) {
      String videoUri = "gs://cloud-samples-data/generative-ai/video/pixel8.mp4";

      GenerativeModel model = new GenerativeModel(modelName, vertexAI);
      GenerateContentResponse response = model.generateContent(
          ContentMaker.fromMultiModalData(
              "Provide a description of the video.\n The description should also "
                  + "contain anything important which people say in the video.",
              PartMaker.fromMimeTypeAndData("video/mp4", videoUri)
          ));

      String output = ResponseHandler.getText(response);
      System.out.println(output);

      return output;
    }
  }
}

Node.js

Réponses en streaming et sans streaming

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 analyze_video_with_audio(projectId = 'PROJECT_ID') {
  const vertexAI = new VertexAI({project: projectId, location: 'us-central1'});

  const generativeModel = vertexAI.getGenerativeModel({
    model: 'gemini-1.5-flash-001',
  });

  const filePart = {
    file_data: {
      file_uri: 'gs://cloud-samples-data/generative-ai/video/pixel8.mp4',
      mime_type: 'video/mp4',
    },
  };
  const textPart = {
    text: `
    Provide a description of the video.
    The description should also contain anything important which people say in the video.`,
  };

  const request = {
    contents: [{role: 'user', parts: [filePart, textPart]}],
  };

  const resp = await generativeModel.generateContent(request);
  const contentResponse = await resp.response;
  console.log(JSON.stringify(contentResponse));
}

C#


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

public class VideoInputWithAudio
{
    public async Task<string> DescribeVideo(
        string projectId = "your-project-id",
        string location = "us-central1",
        string publisher = "google",
        string model = "gemini-1.5-flash-001")
    {

        var predictionServiceClient = new PredictionServiceClientBuilder
        {
            Endpoint = $"{location}-aiplatform.googleapis.com"
        }.Build();

        string prompt = @"Provide a description of the video.
The description should also contain anything important which people say in the video.";

        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { Text = prompt },
                        new Part { FileData = new() { MimeType = "video/mp4", FileUri = "gs://cloud-samples-data/generative-ai/video/pixel8.mp4" }}
                    }
                }
            }
        };

        GenerateContentResponse response = await predictionServiceClient.GenerateContentAsync(generateContentRequest);

        string responseText = response.Candidates[0].Content.Parts[0].Text;
        Console.WriteLine(responseText);

        return responseText;
    }
}

Toutes les modalités

Les exemples de code montrent comment traiter simultanément des images, une vidéo, de l'audio et du texte. Ces exemples fonctionnent avec Gemini 1.5 Pro et Gemini 1.5 Flash.

Python

Réponses en streaming et sans streaming

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, Part

  # TODO(developer): Update and un-comment below lines
  # project_id = "PROJECT_ID"

  vertexai.init(project=project_id, location="us-central1")

  model = GenerativeModel(model_name="gemini-1.5-flash-001")

  video_file_uri = (
      "gs://cloud-samples-data/generative-ai/video/behind_the_scenes_pixel.mp4"
  )
  video_file = Part.from_uri(video_file_uri, mime_type="video/mp4")

  image_file_uri = "gs://cloud-samples-data/generative-ai/image/a-man-and-a-dog.png"
  image_file = Part.from_uri(image_file_uri, mime_type="image/png")

  prompt = """
  Watch each frame in the video carefully and answer the questions.
  Only base your answers strictly on what information is available in the video attached.
  Do not make up any information that is not part of the video and do not be too
  verbose, be to the point.

  Questions:
  - When is the moment in the image happening in the video? Provide a timestamp.
  - What is the context of the moment and what does the narrator say about it?
"""

  contents = [
      video_file,
      image_file,
      prompt,
  ]

  response = model.generate_content(contents)
  print(response.text)

Java

Réponses en streaming et sans streaming

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.ContentMaker;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.PartMaker;
import com.google.cloud.vertexai.generativeai.ResponseHandler;
import java.io.IOException;

public class MultimodalAllInput {

  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.5-flash-001";

    multimodalAllInput(projectId, location, modelName);
  }

  // A request containing a text prompt, a video, and a picture.
  public static String multimodalAllInput(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)) {
      String videoUri = "gs://cloud-samples-data/generative-ai/video/behind_the_scenes_pixel.mp4";
      String imageUri = "gs://cloud-samples-data/generative-ai/image/a-man-and-a-dog.png";

      GenerativeModel model = new GenerativeModel(modelName, vertexAI);
      GenerateContentResponse response = model.generateContent(
          ContentMaker.fromMultiModalData(
              PartMaker.fromMimeTypeAndData("video/mp4", videoUri),
              PartMaker.fromMimeTypeAndData("image/png", imageUri),
              "Watch each frame in the video carefully and answer the questions.\n"
                  + "Only base your answers strictly on what information is available in "
                  + "the video attached. Do not make up any information that is not part "
                  + "of the video and do not be too verbose, be to the point.\n\n"
                  + "Questions:\n"
                  + "- When is the moment in the image happening in the video? "
                  + "Provide a timestamp.\n"
                  + "- What is the context of the moment and what does the narrator say about it?"
          ));

      String output = ResponseHandler.getText(response);
      System.out.println(output);

      return output;
    }
  }
}

Node.js

Réponses en streaming et sans streaming

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 analyze_all_modalities(projectId = 'PROJECT_ID') {
  const vertexAI = new VertexAI({project: projectId, location: 'us-central1'});

  const generativeModel = vertexAI.getGenerativeModel({
    model: 'gemini-1.5-pro-preview-0409',
  });

  const videoFilePart = {
    file_data: {
      file_uri:
        'gs://cloud-samples-data/generative-ai/video/behind_the_scenes_pixel.mp4',
      mime_type: 'video/mp4',
    },
  };
  const imageFilePart = {
    file_data: {
      file_uri:
        'gs://cloud-samples-data/generative-ai/image/a-man-and-a-dog.png',
      mime_type: 'image/png',
    },
  };

  const textPart = {
    text: `
    Watch each frame in the video carefully and answer the questions.
    Only base your answers strictly on what information is available in the video attached.
    Do not make up any information that is not part of the video and do not be too
    verbose, be to the point.

    Questions:
    - When is the moment in the image happening in the video? Provide a timestamp.
    - What is the context of the moment and what does the narrator say about it?`,
  };

  const request = {
    contents: [{role: 'user', parts: [videoFilePart, imageFilePart, textPart]}],
  };

  const resp = await generativeModel.generateContent(request);
  const contentResponse = await resp.response;
  console.log(JSON.stringify(contentResponse));
}

C#


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

public class MultimodalAllInput
{
    public async Task<string> AnswerFromMultimodalInput(
        string projectId = "your-project-id",
        string location = "us-central1",
        string publisher = "google",
        string model = "gemini-1.5-flash-001")
    {

        var predictionServiceClient = new PredictionServiceClientBuilder
        {
            Endpoint = $"{location}-aiplatform.googleapis.com"
        }.Build();

        string prompt = "Watch each frame in the video carefully and answer the questions.\n"
                  + "Only base your answers strictly on what information is available in "
                  + "the video attached. Do not make up any information that is not part "
                  + "of the video and do not be too verbose, be to the point.\n\n"
                  + "Questions:\n"
                  + "- When is the moment in the image happening in the video? "
                  + "Provide a timestamp.\n"
                  + "- What is the context of the moment and what does the narrator say about it?";

        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { Text = prompt },
                        new Part { FileData = new() { MimeType = "video/mp4", FileUri = "gs://cloud-samples-data/generative-ai/video/behind_the_scenes_pixel.mp4" } },
                        new Part { FileData = new() { MimeType = "image/png", FileUri = "gs://cloud-samples-data/generative-ai/image/a-man-and-a-dog.png" } }
                    }
                }
            }
        };

        GenerateContentResponse response = await predictionServiceClient.GenerateContentAsync(generateContentRequest);

        string responseText = response.Candidates[0].Content.Parts[0].Text;
        Console.WriteLine(responseText);

        return responseText;
    }
}

Définir les paramètres de modèle

Les paramètres de modèle suivants peuvent être définis sur les modèles multimodaux :

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

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.

Valeurs de paramètre valides

Paramètre	Gemini 1.0 Pro Vision	Gemini 1.5 Pro	Gemini 1.5 Flash
Top-K	1 - 40 (valeur par défaut : 32)	Non compatible	Non compatible
Top-P	0 - 1.0 (par défaut 1.0)	0 - 1.0 (par défaut 0.95)	0 - 1.0 (par défaut 0.95)
Température	0 - 1.0 (par défaut 0.4)	0 - 2.0 (par défaut 1.0)	0 - 2.0 (par défaut 1.0)

Exigences pour le contenu multimédia

Lorsque vous utilisez un fichier multimédia dans vos requêtes, assurez-vous qu'il répond aux exigences suivantes :

Exigences liées aux images

Les modèles multimodaux Gemini sont compatibles avec les types vidéo MIME suivants :

Type MIME de l'image	Gemini 1.5 Flash	Gemini 1.5 Pro	Gemini 1.0 Pro Vision
PNG - `image/png`
JPEG - `image/jpeg`

Il n'y a pas de limite spécifique au nombre de pixels dans une image. Cependant, les images plus volumineuses sont réduites et remplies pour correspondre à une résolution maximale de 3072 x 3072, tout en préservant leur format d'origine.

Pour Gemini 1.0 Pro Vision, chaque image compte pour 258 jetons.

Pour Gemini 1.5 Flash et Gemini 1.5 Pro :

Si les deux dimensions du format d'une image sont inférieures ou égales à 384, 258 jetons sont utilisés.
Si l'une des dimensions du format d'une image est supérieure à 384, l'image est recadrée en vignettes. Chaque taille de vignette est définie par défaut sur la plus petite dimension (largeur ou hauteur), divisée par 1,5. Si nécessaire, chaque vignette est ajustée pour qu'elle ne soit pas inférieure à 256 et ne dépasse pas 768. Chaque vignette est ensuite redimensionnée au format 768x768 et utilise 258 jetons.

Le nombre maximal d'images pouvant être incluses dans une requête est le suivant :

16 pour Gemini 1.0 Pro Vision
3 000 pour Gemini 1.5 Flash et Gemini 1.5 Pro

Exigences pour le contenu audio

Gemini 1.5 Flash et Gemini 1.5 Pro sont compatibles avec les types MIME audio suivants. Gemini 1.0 Pro Vision n'est pas compatible avec l'audio.

Type MIME audio	Gemini 1.5 Flash	Gemini 1.5 Pro	Gemini 1.0 Pro Vision
AAC - `audio/aac`
FLAC - `audio/flac`
MP3 - `audio/mp3`
MPA - `audio/m4a`
MPEG - `audio/mpeg`
MPGA - `audio/mpga`
MP4 - `audio/mp4`
OPUS - `audio/opus`
PCM - `audio/pcm`
WAV - `audio/wav`
WEBM - `audio/webm`

Exigences pour le contenu vidéo

Les vidéos sont échantillonnées à 1 FPS. Chaque image vidéo équivaut à 258 jetons.

Pour Gemini 1.5 Flash et Gemini 1.5 Pro, la piste audio est encodée avec des trames vidéo. La piste audio est également divisée en segments d'une seconde, chacune représentant 32 jetons. Les trames vidéo et les jetons audio sont entrelacés avec leurs codes temporels. Les codes temporels sont représentés par 7 jetons.

Les modèles multimodaux Gemini sont compatibles avec les types vidéo MIME suivants :

Type vidéo MIME	Gemini 1.5 Flash	Gemini 1.5 Pro	Gemini 1.0 Pro Vision
FLV - `video/x-flv`
MOV - `video/mov`
MPEG - `video/mpeg`
MPEGPS - `video/mpegps`
MPG - `video/mpg`
MP4 - `video/mp4`
WEBM - `video/webm`
WMV - `video/wmv`
3GPP - `video/3gpp`

Exigences pour le format PDF

Le type MIME requis pour un PDF est application/pdf.

Bonnes pratiques

Cette section présente les bonnes pratiques pour différentes modalités.

Bonnes pratiques pour les images

Lorsque vous utilisez des images, suivez les bonnes pratiques et les informations ci-dessous pour obtenir de meilleurs résultats.

Utilisez des requêtes avec une seule image pour produire de meilleurs résultats qu'avec des requêtes comportant plusieurs images lorsque vous souhaitez détecter du texte dans une image.
Si votre requête contient une seule image, placez-la avant la requête textuelle.
Si la requête contient plusieurs images, et que vous souhaitez les référencer ultérieurement dans votre requête ou demander au modèle de les référencer dans la réponse du modèle, il peut être utile d'attribuer à chaque image un index la précédant. Utilisez a b c ou image 1 image 2 image 3 pour votre index. Voici un exemple d'utilisation d'images indexées dans une requête :
```
image 1 <piano_recital.jpeg>
image 2 <family_dinner.jpeg>
image 3 <coffee_shop.jpeg>

Write a blogpost about my day using image 1 and image 2. Then, give me ideas
for tomorrow based on image 3.
```
Les images dont la résolution est plus élevée offrent de meilleurs résultats.
Incluez quelques exemples dans la requête.
Faites pivoter les images dans l'orientation appropriée avant de les ajouter à la requête.
Évitez les images floues.

Bonnes pratiques pour les vidéos

Lorsque vous utilisez des vidéos, suivez les bonnes pratiques et informations suivantes pour obtenir de meilleurs résultats :

N'utilisez pas plus d'une vidéo par requête.
Si votre requête contient une vidéo, placez-la avant la requête textuelle.
Si vous utilisez Gemini 1.0 Pro Vision, le modèle traite les vidéos en tant que trames d'image non contiguës de la vidéo. Le son n'est pas inclus. Si vous remarquez que le contenu de la vidéo manque dans le modèle, réduisez la durée de la vidéo pour que le modèle enregistre une plus grande partie du contenu vidéo.
Si vous utilisez Gemini 1.0 Pro Vision, seules les informations des deux premières minutes sont traitées.
Si vous utilisez Gemini 1.0 Pro Vision, aucune information audio ni aucune métadonnée d'horodatage n'est analysée. De ce fait, le modèle peut ne pas fonctionner correctement dans les cas d'utilisation nécessitant des entrées audio, comme le sous-titrage de données audio, ou des informations temporelles telles que la vitesse ou le rythme.
Lorsque la localisation d'horodatage est nécessaire dans une vidéo avec audio, demandez au modèle de générer des horodatages au format MM:SS, où les deux premiers chiffres représentent les minutes et les deux derniers chiffres représentent les secondes. Utilisez le même format pour les questions concernant un horodatage.

Bonnes pratiques pour les PDF

Lorsque vous utilisez des fichiers PDF, suivez les bonnes pratiques et informations suivantes pour obtenir de meilleurs résultats :

Les PDF sont traités comme des images. Ainsi, une seule page d'un PDF est traitée comme une seule image.
- Le nombre de pages compatibles est limité au nombre d'images qu'un modèle peut accepter. Pour Gemini 1.0 Pro Vision, la limite est de 16. Pour Gemini 1.5 Pro et Gemini 1.5 Flash, la limite est de 300. Si votre document est long, envisagez de le diviser en plusieurs fichiers PDF pour le traiter.
- Lorsque vous utilisez des fichiers PDF en entrée, le coût suit les tarifs de Gemini pour les images. Par exemple, si vous incluez un fichier PDF de deux pages dans un appel d'API Gemini, des frais d'entrée pour le traitement de deux images vous sont facturés.
Si votre requête contient un fichier PDF, placez-le avant la requête textuelle.
Utilisez des PDF créés avec du texte affiché sous forme de texte plutôt que d'utiliser du texte dans des images numérisées. Ce format garantit que le texte est lisible par un ordinateur, ce qui permet au modèle de le modifier, d'effectuer des recherches et de le manipuler plus facilement qu'avec des fichiers PDF constitués d'images scannées. Cette bonne pratique fournit des résultats optimaux lorsque vous travaillez avec des documents contenant beaucoup de texte (par exemple, des contrats).

Pour obtenir d'autres conseils sur les requêtes multimodales, consultez Concevoir des requêtes multimodales.

Limites multimodales

Bien que les modèles multimodaux Gemini soient puissants dans de nombreux cas d'utilisation multimodaux, il est important de comprendre les limites des modèles :

Raisonnement spatial : les modèles ne parviennent pas à localiser précisément du texte ou des objets dans des images et des PDF. Ils peuvent ne renvoyer que des décomptes approximatifs d'objets.
Utilisations médicales : les modèles ne conviennent pas à l'interprétation d'images médicales (par exemple, les radiographies et les scanners), ni à la fourniture de conseils médicaux.
Reconnaissance de personnes : les modèles ne sont conçus pour identifier des personnes qui ne sont pas des célébrités sur des images.
Modération de contenus : les modèles refusent de fournir des réponses sur des images ou vidéos qui ne respectent pas nos règles de sécurité.
Précision : les modèles peuvent halluciner ou faire des erreurs lors de l'interprétation d'images de basse qualité, retournées ou d'extrêmement basse résolution. Les modèles peuvent également halluciner lors de l'interprétation de texte manuscrit dans des images ou des documents PDF.
Reconnaissance des sons non vocaux : les modèles compatibles avec l'audio peuvent faire des erreurs de reconnaissance avec les sons autres que la parole.
Mouvements très rapides : en raison du taux d'échantillonnage fixe d'une image par seconde (FPS), les modèles peuvent faire des erreurs lors de l'analyse de mouvements très rapides dans des vidéos.
Codes temporels audio : les modèles compatibles avec l'audio ne peuvent pas générer de codes temporels précis pour les requêtes contenant des fichiers audio. Cela inclut les codes temporels de segmentation et de localisation temporelle. Les codes temporels peuvent être générés avec précision pour les entrées incluant une vidéo contenant de l'audio.
Ponctuation de la transcription : les transcriptions renvoyées par Gemini 1.5 Flash peuvent ne pas inclure de ponctuation.

Étapes suivantes

Commencez à créer des modèles multimodaux Gemini. Les nouveaux clients reçoivent 300 $ de crédits Google Cloud gratuits pour découvrir ce qu'ils peuvent faire avec Gemini.
Découvrez comment concevoir des requêtes multimodales.
Découvrez comment envoyer des requêtes de chat.
Découvrez les bonnes pratiques d'IA responsable et les filtres de sécurité de Vertex AI.