Texte

Les modèles de fondation PaLM 2 pour le texte (text-bison, text-unicorn) sont optimisés pour diverses tâches du 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 idéaux 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 d'invites de texte, consultez la section Concevoir des invites de texte.

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 Non applicable
text-bison@001 7 juin 2023 6 juillet 2024
modèle text-unicorn Date de disponibilité Date d'arrêt
text-unicorn@001 30 novembre 2023 Non applicable

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

Paramètre Description Valeurs acceptables

prompt

 Entrée de texte pour générer une réponse du modèle. Les invites 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 invites 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 invite 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_id}/locations/global/collections/{collection_name}/dataStores/{DATA_STORE_ID}

candidateCount

 Nombre de variantes de réponse à renvoyer.

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

 Le décodeur génère du bruit aléatoire avec un générateur de nombres pseudo-aléatoires. Le bruit de température * est ajouté aux fonctions logit avant l'échantillonnage. Le générateur de nombres pseudo-aléatoires (prng) prend une valeur initiale en entrée, et génère la même sortie avec la même valeur initiale.

Si elle n'est pas définie, la valeur initiale utilisée dans le décodeur ne sera pas déterministe. Par conséquent, le bruit aléatoire généré ne sera pas déterministe. Si la valeur initiale est définie, le bruit aléatoire généré sera déterministe.

Optional

Exemple de requête

REST

Pour tester une invite 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 :

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

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

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.

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

import vertexai
from vertexai.language_models import TextGenerationModel

def interview(
    temperature: float,
    project_id: str,
    location: str,
) -> str:
    """Ideation example with a Large Language Model"""

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

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

    return response.text

if __name__ == "__main__":
    interview()

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 la page Configurer l'authentification pour un environnement de développement local. 

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';
const aiplatform = require('@google-cloud/aiplatform');

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

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

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

const publisher = 'google';
const model = 'text-bison@001';

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

async function callPredict() {
  // Configure the parent resource
  const endpoint = `projects/${project}/locations/${location}/publishers/${publisher}/models/${model}`;

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

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

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

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

callPredict();

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.

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


import com.google.cloud.aiplatform.v1beta1.EndpointName;
import com.google.cloud.aiplatform.v1beta1.PredictResponse;
import com.google.cloud.aiplatform.v1beta1.PredictionServiceClient;
import com.google.cloud.aiplatform.v1beta1.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 pour laquelle l'entrée ou la sortie a été bloquée. Pour obtenir la liste des codes d'erreur, consultez la page 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 invites, 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.