Texte

Les modèles de fondation PaLM 2 pour le texte (text-bison, text-unicorn) sont optimisés pour diverses tâches en langage naturel, telles que l'analyse des sentiments, l'extraction d'entités et la création de contenus. Les types de contenus que les modèles PaLM 2 pour le texte peuvent créer incluent des résumés de documents, des réponses à des questions et des étiquettes qui classent du contenu.

Les modèles PaLM 2 pour le texte sont parfaits pour les tâches pouvant être effectuées avec une seule réponse d'API, sans nécessiter de conversation continue. Pour les tâches textuelles nécessitant des échanges aller-retour, utilisez l'IA générative sur l'API Vertex AI pour le chat.

Pour explorer les modèles dans la console, sélectionnez la fiche de modèle PaLM 2 pour le texte dans Model Garden.
Accéder à Model Garden

Cas d'utilisation

Synthèse : créez une version plus courte d'un document intégrant des informations pertinentes à partir du texte d'origine. Par exemple, vous pouvez résumer un chapitre d'un manuel. Vous pouvez également créer une description récapitulative du produit à partir d'un long paragraphe décrivant le produit en détail.
Systèmes de questions-réponses : fournir des réponses aux questions sous forme de texte. Par exemple, vous pouvez automatiser la création d'un document de questions fréquentes (FAQ) à partir du contenu de la base de connaissances.
Classification : attribuer une étiquette au texte fourni. Par exemple, un libellé peut être appliqué à un texte décrivant son exactitude grammaticale.
Analyse des sentiments : il s'agit d'une forme de classification qui identifie le sentiment du texte. Le sentiment est transformé en étiquette appliquée au texte. Par exemple, le sentiment du texte peut être des polarités comme positives ou négatives, ou des sentiments comme de la colère ou de la satisfaction.
Extraction d'entités : extraire une information à partir d'un texte. Par exemple, vous pouvez extraire le nom d'un film à partir du texte d'un article.

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

Requête HTTP

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

Pour plus d'informations, consultez la méthode predict.

Versions de modèle

Pour utiliser la dernière version de modèle, spécifiez le nom du modèle sans numéro de version, par exemple text-bison.

Pour utiliser une version de modèle stable, indiquez le numéro de version du modèle, par exemple text-bison@002. Chaque version stable est disponible pendant six mois après la date de disponibilité de la version stable ultérieure.

Le tableau suivant contient les versions de modèle stable disponibles :

modèle text-bison	Date de disponibilité	Date d'arrêt
text-bison@002	6 décembre 2023	9 octobre 2024

modèle text-unicorn	Date de disponibilité	Date d'arrêt
text-unicorn@001	30 novembre 2023	Au plus tôt le 30 novembre 2024

Pour en savoir plus, consultez la page Versions et cycle de vie des modèles.

Corps de la requête

{
  "instances": [
    {
      "prompt": string
    }
  ],
  "parameters": {
    "temperature": number,
    "maxOutputTokens": integer,
    "topK": integer,
    "topP": number,
    "groundingConfig": string,
    "stopSequences": [ string ],
    "candidateCount": integer,
    "logprobs": integer,
    "presencePenalty": float,
    "frequencyPenalty": float,
    "echo": boolean,
    "seed": integer
  }
}

Utilisez les paramètres suivants pour le modèle de texte text-bison. Pour en savoir plus, consultez la section Concevoir des requêtes textuelles.

Paramètre	Description	Valeurs acceptables
`prompt`	Entrée de texte pour générer une réponse du modèle. Les requêtes peuvent inclure un préambule, des questions, des suggestions, des instructions ou des exemples.	Texte
`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.	`0.0–1.0` `Default: 0.0`
`maxOutputTokens`	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.	`1–2048` pour text-bison (la plus récente) `1–1024` pour text-bison@002 `Default: 1024`
`topK`	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.	`1–40` `Default: 40`
`topP`	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.	`0.0–1.0` `Default: 0.95`
`stopSequence`	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`	`default: []`
`groundingConfig`	L'ancrage vous permet de faire référence à des données spécifiques lorsque vous utilisez des modèles de langage. Lorsque vous ancrez un modèle, celui-ci peut utiliser des données internes, confidentielles et spécifiques de votre dépôt comme référentiel et inclure ces données dans la réponse. Seuls les data stores de Vertex AI Search sont compatibles.	Le chemin d'accès doit respecter le format suivant : `projects/{project_number_or_id}/locations/global/collections/{collection_name}/dataStores/{DATA_STORE_ID}`
`candidateCount`	Nombre de variantes de réponse à renvoyer. Pour chaque requête, vous êtes facturé pour les jetons de sortie de tous les candidats, mais vous ne payez qu'une seule fois pour les jetons d'entrée. La spécification de plusieurs candidats est une fonctionnalité bêta qui fonctionne avec `generateContent` (`streamGenerateContent` n'est pas disponible). Les modèles suivants sont compatibles : Gemini 1.5 Flash : `1`-`8` (par défaut : `1`) Gemini 1.5 Pro : `1`-`8` (par défaut : `1`)	`1–4` `Default: 1`
`logprobs`	Renvoie les principaux jetons candidats les plus probables `logprobs` avec leurs probabilités logarithmiques à chaque étape de génération. Les jetons choisis et leurs probabilités logarithmiques sont toujours renvoyés à chaque étape. Le jeton choisi peut se trouver ou non dans les principaux candidats les plus probables `logprobs`.	`0-5`
`frequencyPenalty`	Les valeurs positives pénalisent les jetons qui apparaissent de manière répétée dans le texte généré, ce qui réduit la probabilité de répétition du contenu. Les valeurs acceptées sont `-2.0`—`2.0`.	`Minimum value: -2.0` `Maximum value: 2.0`
`presencePenalty`	Les valeurs positives pénalisent les jetons qui apparaissent déjà dans le texte généré, ce qui augmente la probabilité de générer un contenu plus diversifié. Les valeurs acceptées sont `-2.0`—`2.0`.	`Minimum value: -2.0` `Maximum value: 2.0`
`echo`	Si la valeur est "true", la requête est renvoyée dans le texte généré.	`Optional`
`seed`	Lorsque la graine est fixée à une valeur spécifique, le modèle s'efforce de fournir la même réponse pour les requêtes répétées. La sortie déterministe n'est pas garantie. De plus, la modification du modèle ou des paramètres, comme la température, peut entraîner des variations dans la réponse, même si vous utilisez la même valeur de graine. Par défaut, une valeur de graine aléatoire est utilisée. Il s'agit d'une fonctionnalité en preview.	`Optional`

Exemple de requête

REST

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

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

PROJECT_ID : l'ID de votre projet.

Pour les autres champs, consultez le tableau Corps de la requête.

Méthode HTTP et URL :

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

Corps JSON de la requête :

{
  "instances": [
    { "prompt": "Give me ten interview questions for the role of program manager."}
  ],
  "parameters": {
    "temperature": 0.2,
    "maxOutputTokens": 256,
    "topK": 40,
    "topP": 0.95,
    "logprobs": 2
  }
}

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

curl

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

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

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/text-bison:predict"

PowerShell

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

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

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/text-bison:predict" | Select-Object -Expand Content

Vous devriez recevoir une réponse JSON semblable à l'exemple de réponse.

Python

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

import vertexai

from vertexai.language_models import TextGenerationModel

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

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

Node.js

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

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.

/**
 * TODO(developer): Update these variables before running the sample.
 */
const PROJECT_ID = process.env.CAIP_PROJECT_ID;
const LOCATION = 'us-central1';
const PUBLISHER = 'google';
const MODEL = 'text-bison@001';
const aiplatform = require('@google-cloud/aiplatform');

// Imports the Google Cloud Prediction service client
const {PredictionServiceClient} = aiplatform.v1;

// Import the helper module for converting arbitrary protobuf.Value objects.
const {helpers} = aiplatform;

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

// Instantiates a client
const predictionServiceClient = new PredictionServiceClient(clientOptions);

async function callPredict() {
  // Configure the parent resource
  const endpoint = `projects/${PROJECT_ID}/locations/${LOCATION}/publishers/${PUBLISHER}/models/${MODEL}`;

  const prompt = {
    prompt:
      'Give me ten interview questions for the role of program manager.',
  };
  const instanceValue = helpers.toValue(prompt);
  const instances = [instanceValue];

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

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

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

callPredict();

Java

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


import com.google.cloud.aiplatform.v1.EndpointName;
import com.google.cloud.aiplatform.v1.PredictResponse;
import com.google.cloud.aiplatform.v1.PredictionServiceClient;
import com.google.cloud.aiplatform.v1.PredictionServiceSettings;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class PredictTextPromptSample {

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

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

  // Get a text prompt from a supported text model
  public static void predictTextPrompt(
      String instance,
      String parameters,
      String project,
      String location,
      String publisher,
      String model)
      throws IOException {
    String endpoint = String.format("%s-aiplatform.googleapis.com:443", location);
    PredictionServiceSettings predictionServiceSettings =
        PredictionServiceSettings.newBuilder().setEndpoint(endpoint).build();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (PredictionServiceClient predictionServiceClient =
        PredictionServiceClient.create(predictionServiceSettings)) {
      final EndpointName endpointName =
          EndpointName.ofProjectLocationPublisherModelName(project, location, publisher, model);

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

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

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

Corps de la réponse

{
  "predictions":[
    {
      "content": string,
      "citationMetadata": {
        "citations": [
          {
            "startIndex": integer,
            "endIndex": integer,
            "url": string,
            "title": string,
            "license": string,
            "publicationDate": string
          }
        ]
      },
      "logprobs": {
        "tokenLogProbs": [ float ],
        "tokens": [ string ],
        "topLogProbs": [ { map<string, float> } ]
      },
      "safetyAttributes": {
        "categories": [ string ],
        "blocked": boolean,
        "scores": [ float ],
        "errors": [ int ]
      }
    }
  ],
  "metadata": {
    "tokenMetadata": {
      "input_token_count": {
        "total_tokens": integer,
        "total_billable_characters": integer
      },
      "output_token_count": {
        "total_tokens": integer,
        "total_billable_characters": integer
      }
    }
  }
}

Élément de réponse	Description
`content`	Résultat généré à partir du texte d'entrée.
`categories`	Noms à afficher des catégories d'attributs de sécurité associées au contenu généré. L'ordre correspond aux scores.
`scores`	Les scores de confiance de chaque catégorie, une valeur supérieure, signifie une confiance plus élevée.
`blocked`	Option indiquant si l'entrée ou la sortie du modèle a été bloquée.
`errors`	Code d'erreur qui identifie la raison du blocage de l'entrée ou de la sortie. Pour obtenir la liste des codes d'erreur, consultez la section Filtres et attributs de sécurité.
`startIndex`	Index dans le résultat de la prédiction où la citation commence (inclus). Doit être supérieur ou égal à 0 et < end_index.
`endIndex`	Index de la sortie de prédiction où la citation se termine (exclusive). Doit être > start_index et < len(sortie).
`url`	URL associée à cette citation. Si elle est présente, cette URL renvoie vers la page Web de la source de la citation. Les URL possibles incluent les sites d'actualités, les dépôts GitHub, etc.
`title`	Titre associé à cette citation. Si elle est présente, il s'agit du titre de la source de cette citation. Les titres possibles sont les titres des actualités et des livres, etc.
`license`	Licence associée à cette référence. Se elle est présente, il s'agit de la licence de la source de cette citation. Les licences possibles incluent les licences de code, par exemple licence MIT.
`publicationDate`	Date de publication associée à cette citation. Le cas échéant, il s'agit de la date à laquelle la source de cette citation a été publiée. Les formats possibles sont AAAA, AAAA-MM, AAAA-MM-JJ.
`input_token_count`	Nombre de jetons d'entrée. Il s'agit du nombre total de jetons pour l'ensemble des requêtes, préfixes et suffixes.
`output_token_count`	Nombre de jetons de sortie. Il s'agit du nombre total de jetons dans `content` pour l'ensemble des prédictions.
`tokens`	Jetons échantillonnés.
`tokenLogProbs`	Probabilités logarithmiques des journaux échantillonnés.
`topLogProb`	Jetons candidats les plus probables et leurs probabilités logarithmiques à chaque étape.
`logprobs`	Résultats du paramètre "logprobs". Le mappage 1-1 correspond aux candidats.

Exemple de réponse

{
  "predictions": [
    {
      "citationMetadata":{
        "citations": [ ]
      },
      "safetyAttributes":{
        "scores": [
          0.1
        ],
        "categories": [
          "Finance"
        ],
        "blocked": false
      },
      "content":"1. What is your experience with project management?\n2. What are your strengths and weaknesses as a project manager?\n3. How do you handle conflict and difficult situations?\n4. How do you communicate with stakeholders?\n5. How do you stay organized and on track?\n6. How do you manage your time effectively?\n7. What are your goals for your career?\n8. Why are you interested in this position?\n9. What are your salary expectations?\n10. What are your availability and start date?",
      "logprobs": {
        "tokenLogProbs": [
          -0.1,
          -0.2
        ],
        "tokens": [
          "vertex",
          " rocks!"
        ],
        "topLogProbs": [
          {
            "vertex": -0.1,
            "hello": -0.2
          },
          {
            " rocks!": -0.2,
            " world!": -0.3
          }
        ]
      }
    },
    "metadata": {
      "tokenMetadata": {
        "outputTokenCount": {
          "totalTokens": 153,
          "totalBillableCharacters": 537
        },
        "inputTokenCount": {
          "totalBillableCharacters": 54,
          "totalTokens": 12
        }
      }
    }
  ]
}

Réponse en streaming des modèles Generative AI

Les paramètres sont identiques pour les requêtes en streaming et sans streaming vers les API.

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

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