Chat di testo

Il modello di base PaLM 2 for Chat (chat-bison) è un modello linguistico di grandi dimensioni (LLM) che eccelle in comprensione del linguaggio, generazione del linguaggio e conversazioni. Questo modello di chat è ottimizzato per condurre conversazioni naturali in più passaggi ed è ideale per attività su codice che richiedono interazioni di continuo.

Per attività di testo che possono essere completate con un'unica risposta dell'API (senza la necessità di una conversazione continua), utilizza il modello di testo.

Per esplorare questo modello nella console, consulta la scheda del modello PaLM 2 per Chat nella Model Garden.
Vai a Model Garden

Casi d'uso

• Assistenza clienti: indica al modello di rispondere come agenti dell'assistenza clienti che parlano solo del prodotto

• Assistenza tecnica: fornisci al modello una chiamata per interagire con i clienti dell'agente del centro con parametri specifici su come rispondere e cosa non dire

• Utenti tipo e personaggi: indica al modello di rispondere nello stile di una una persona specifica ("...nello stile di Shakespeare")

• Companion nel sito web: crea un assistente conversazionale per lo shopping, i viaggi e altri casi d'uso

Per ulteriori informazioni, consulta la sezione Progettare prompt di chat.

Richiesta HTTP

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

Per ulteriori informazioni, consulta il metodo predict.

Versioni modello

Per utilizzare la versione più recente del modello, specifica il nome del modello senza numero di versione, ad esempio chat-bison.

Per utilizzare una versione del modello stabile, specifica il numero di versione del modello, ad esempio chat-bison@002. Ciascuna stabile sarà disponibile per sei mesi dopo la data di rilascio dell' alla versione stabile successiva.

La tabella seguente contiene le versioni dei modelli stabili disponibili:

modello chat-bison	Data di uscita	Data di interruzione
chat-bison@002	6 dicembre 2023	9 ottobre 2024

Per saperne di più, consulta Versioni dei modelli e ciclo di vita.

Corpo della richiesta

{
  "instances": [
    {
      "context":  string,
      "examples": [
        {
          "input": { "content": string },
          "output": { "content": string }
        }
      ],
      "messages": [
        {
          "author": string,
          "content": string,
        }
      ],
    }
  ],
  "parameters": {
    "temperature": number,
    "maxOutputTokens": integer,
    "topP": number,
    "topK": integer,
    "groundingConfig": string,
    "stopSequences": [ string ],
    "candidateCount": integer
    "logprobs": integer,
    "presencePenalty": float,
    "frequencyPenalty": float,
    "seed": integer
  }
}

Per le chiamate API di chat, i campi context, examples e messages si combinano per formare il prompt. La tabella seguente mostra i parametri da configurare per l'API Vertex AI PaLM per il testo:

Parametro	Descrizione	Valori accettabili
context (facoltativo)	Il contesto determina il modo in cui risponde il modello durante la conversazione. Ad esempio, puoi utilizzare il contesto per specificare le parole che il modello può o non può utilizzare, gli argomenti su cui deve concentrarsi o che deve evitare oppure il formato o lo stile della risposta.	Testo
examples (facoltativo)	Esempi per consentire al modello di imparare a rispondere alla conversazione.	[{ "input": {"content": "provide content"}, "output": {"content": "provide content"} }]
messages (obbligatorio)	Cronologia della conversazione fornita al modello in un formato strutturato di autore alternativo. I messaggi vengono visualizzati in ordine cronologico: dal meno recente al più recente. Quando la cronologia dei messaggi fa sì che l'input superi la lunghezza massima, i messaggi meno recenti vengono rimossi fino a quando l'intero prompt non rientra nel limite consentito.	[{ "author": "user", "content": "user message" }]
temperature	La temperatura viene utilizzata per il campionamento durante la generazione della risposta, che si verifica quando topP e topK. La temperatura controlla il grado di casualità nella selezione dei token. Le temperature più basse sono ideali per prompt che richiedono una risposta meno aperta o creativa, mentre temperature più alte possono portare a risultati più diversificati o creativi. Una temperatura di 0 significa che vengono sempre selezionati i token con la probabilità più alta. In questo caso, le risposte per un determinato sono per lo più deterministici, ma è ancora possibile una piccola variazione. Se il modello restituisce una risposta troppo generica, troppo breve, oppure fornisce una risposta di riserva di risposta, prova ad aumentare la temperatura.	0.0–1.0 Default: 0.0
maxOutputTokens	Numero massimo di token che possono essere generati nella risposta. Un token è di circa quattro caratteri. 100 token corrispondono a circa 60-80 parole. Specifica un valore più basso per risposte più brevi e un valore più alto per risposte potenzialmente più lunghe diverse.	1–2048 Default: 1024
topK	Top-K cambia il modo in cui il modello seleziona i token per l'output. Un top-K di 1 significa che il successivo token selezionato è il più probabile tra tutti nel vocabolario del modello (chiamato anche decodifica greedy), mentre una top-K di 3 significa che il token successivo viene selezionato tra i tre probabili token utilizzando la temperatura. Per ogni passaggio di selezione dei token, vengono mostrati i token top-K con il vengono campionate. Quindi i token vengono ulteriormente filtrati in base a top-P con il token finale selezionato utilizzando il campionamento della temperatura. Specifica un valore più basso per risposte meno casuali e un valore più alto per più risposte risposte casuali.	1–40 Default: 40
topP	Top-P cambia il modo in cui il modello seleziona i token per l'output. Token selezionati dal più probabile (vedi top-K) al meno probabile fino alla somma delle probabilità equivale al valore di top-P. Ad esempio, se i token A, B e C hanno una probabilità di 0,3, 0,2 e 0,1 e il valore di top-P è 0.5, il modello seleziona A o B come token successivo utilizzando la temperatura ed esclude C come candidato. Specifica un valore più basso per risposte meno casuali e un valore più alto per più risposte risposte casuali.	0.0–1.0 Default: 0.95
stopSequences	Specifica un elenco di stringhe che indicano al modello di interrompere la generazione di testo se uno delle stringhe incontrate nella risposta. Se una stringa è presente in più volte in una risposta, la risposta viene troncata nel punto in cui viene rilevata per la prima volta. Le stringhe sono sensibili alle maiuscole. Ad esempio, se la seguente è la risposta restituita quando stopSequences non è specificato: public static string reverse(string myString) Quindi la risposta restituita con il campo stopSequences impostato su ["Str", "reverse"] è: public static string	default: []
groundingConfig	Il grounding ti consente di fare riferimento a dati specifici quando utilizzi modelli linguistici. Quando base di un modello, questo può fare riferimento a dati interni, riservati e comunque specifici repository e includere i dati nella risposta. Sono supportati solo i datastore di Vertex AI Search.	Il percorso deve avere il seguente formato: projects/{project_id}/locations/global/collections/{collection_name}/dataStores/{DATA_STORE_ID}
candidateCount	Il numero di varianti della risposta da restituire.	1–4 Default: 1
logprobs	Restituisce i primi logprobs token candidati più probabili con le relative probabilità di log in ogni passaggio della generazione. I token scelti e le relative probabilità di log in ogni passaggio vengono sempre restituiti. Il token scelto potrebbe essere o meno tra i primi logprobs con maggiore probabilità candidati.	0-5
frequencyPenalty	I valori positivi penalizzano i token che appaiono ripetutamente nel testo generato, diminuendo probabilità di ripetere i contenuti. I valori accettati sono -2.0-2.0.	Minimum value: -2.0 Maximum value: 2.0
presencePenalty	I valori positivi penalizzano i token già presenti nel testo generato, aumentando il valore probabilità di generare contenuti più diversificati. I valori accettati sono -2.0—2.0.	Minimum value: -2.0 Maximum value: 2.0
seed	Il decodificatore genera rumore casuale con uno pseudo generatore di numeri casuali; viene aggiunto il rumore della temperatura * ai logit prima del campionamento. Lo pseudo generatore di numeri casuali (prng) prende un seed come input, genera lo stesso output con lo stesso seed. Se il seed non è impostato, il seed utilizzato nel decoder non sarà deterministico, quindi l'output casuale il rumore non sarà deterministico. Se il seed è impostato, il rumore casuale generato sarà deterministici.	Optional

Richiesta di esempio

REST

Per testare una chat di testo utilizzando l'API Vertex AI, invia una richiesta POST all' endpoint del modello del publisher.

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

• PROJECT_ID: il tuo ID progetto.

Per gli altri campi, consulta la tabella Corpo della richiesta riportata di seguito.

Metodo HTTP e URL:

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

Corpo JSON della richiesta:

{
  "instances": [{
      "context":  "CONTEXT",
      "examples": [
       { 
          "input": {"content": "EXAMPLE_INPUT"},
          "output": {"content": "EXAMPLE_OUTPUT"}
       }],
      "messages": [
       { 
          "author": "AUTHOR",
          "content": "CONTENT",
       }],
   }],
  "parameters": {
    "temperature": TEMPERATURE,
    "maxOutputTokens": MAX_OUTPUT_TOKENS,
    "topP": TOP_P,
    "topK": TOP_K
  }
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Nota: Il comando seguente presuppone che tu abbia eseguito l'accesso a l'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti consente di accedere automaticamente all'interfaccia a riga di comando gcloud . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json. ed esegui questo comando:

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/chat-bison:predict"

PowerShell

Nota: Il comando seguente presuppone che tu abbia eseguito l'accesso a l'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json. ed esegui questo comando:

$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/chat-bison:predict" | Select-Object -Expand Content

Dovresti ricevere una risposta JSON simile alla risposta di esempio.

Python

Per scoprire come installare o aggiornare l'SDK Vertex AI per Python, vedi Installare l'SDK Vertex AI per Python. Per ulteriori informazioni, consulta documentazione di riferimento dell'API Python.

def send_chat() -> str:
    from vertexai.language_models import ChatModel, InputOutputTextPair

    chat_model = ChatModel.from_pretrained("chat-bison@002")

    parameters = {
        "temperature": 0.2,
        "max_output_tokens": 256,
        "top_p": 0.95,
        "top_k": 40,
    }

    chat = chat_model.start_chat(
        context="My name is Miles. You are an astronomer, knowledgeable about the solar system.",
        examples=[
            InputOutputTextPair(
                input_text="How many moons does Mars have?",
                output_text="The planet Mars has two moons, Phobos and Deimos.",
            ),
        ],
    )

    response = chat.send_message(
        "How many planets are there in the solar system?", **parameters
    )
    print(response.text)

    return response.text

Node.js

Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nel Guida rapida di Vertex AI con librerie client. Per ulteriori informazioni, consulta API Node.js Vertex AI documentazione di riferimento.

Per eseguire l'autenticazione su Vertex AI, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

/**
 * 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 = 'chat-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 = {
    context:
      'My name is Miles. You are an astronomer, knowledgeable about the solar system.',
    examples: [
      {
        input: {content: 'How many moons does Mars have?'},
        output: {
          content: 'The planet Mars has two moons, Phobos and Deimos.',
        },
      },
    ],
    messages: [
      {
        author: 'user',
        content: 'How many planets are there in the solar system?',
      },
    ],
  };
  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 chat prompt response');
  const predictions = response.predictions;
  console.log('\tPredictions :');
  for (const prediction of predictions) {
    console.log(`\t\tPrediction : ${JSON.stringify(prediction)}`);
  }
}

callPredict();

Java

Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nel Guida rapida di Vertex AI con librerie client. Per ulteriori informazioni, consulta API Java Vertex AI documentazione di riferimento.

Per eseguire l'autenticazione su Vertex AI, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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;

// Send a Predict request to a large language model to test a chat prompt
public class PredictChatPromptSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String instance =
        "{\n"
            + "   \"context\":  \"My name is Ned. You are my personal assistant. My favorite movies"
            + " are Lord of the Rings and Hobbit.\",\n"
            + "   \"examples\": [ { \n"
            + "       \"input\": {\"content\": \"Who do you work for?\"},\n"
            + "       \"output\": {\"content\": \"I work for Ned.\"}\n"
            + "    },\n"
            + "    { \n"
            + "       \"input\": {\"content\": \"What do I like?\"},\n"
            + "       \"output\": {\"content\": \"Ned likes watching movies.\"}\n"
            + "    }],\n"
            + "   \"messages\": [\n"
            + "    { \n"
            + "       \"author\": \"user\",\n"
            + "       \"content\": \"Are my favorite movies based on a book series?\"\n"
            + "    }]\n"
            + "}";
    String parameters =
        "{\n"
            + "  \"temperature\": 0.3,\n"
            + "  \"maxDecodeSteps\": 200,\n"
            + "  \"topP\": 0.8,\n"
            + "  \"topK\": 40\n"
            + "}";
    String project = "YOUR_PROJECT_ID";
    String publisher = "google";
    String model = "chat-bison@001";

    predictChatPrompt(instance, parameters, project, publisher, model);
  }

  static void predictChatPrompt(
      String instance, String parameters, String project, String publisher, String model)
      throws IOException {
    PredictionServiceSettings predictionServiceSettings =
        PredictionServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .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)) {
      String location = "us-central1";
      final EndpointName endpointName =
          EndpointName.ofProjectLocationPublisherModelName(project, location, publisher, model);

      Value.Builder instanceValue = Value.newBuilder();
      JsonFormat.parser().merge(instance, instanceValue);
      List<Value> instances = new ArrayList<>();
      instances.add(instanceValue.build());

      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");
    }
  }
}

Corpo della risposta

{
  "predictions": [
    {
      "candidates": [
        {
          "author": string,
          "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": false,
        "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
      }
    }
  }
}

Elemento risposta	Descrizione
content	Contenuto del testo del messaggio di chat.
candidates	Il risultato della chat generato dal messaggio specificato.
categories	I nomi visualizzati delle categorie degli attributi di sicurezza associate ai contenuti generati. L'ordine corrisponde ai punteggi.
author	Tag dell'autore per il turno.
scores	I punteggi di confidenza di ogni categoria. Un valore più alto corrisponde a una confidenza maggiore.
blocked	Un flag che indica se l'input o l'output del modello è stato bloccato.
startIndex	Indice nell'output della previsione dove inizia la citazione (inclusa). Devono essere >= 0 e < indice_finale.
endIndex	Indice nell'output della previsione dove termina la citazione (esclusa). Deve avere > start_index e < len(output).
url	URL associato a questa citazione. Se presente, l'URL rimanda alla pagina web della fonte della citazione. I possibili URL includono siti web di notizie, repository GitHub e così via.
title	Titolo associato a questa citazione. Se presente, si riferisce al titolo della fonte di questa citazione. I titoli possibili includono quelli di notizie, libri e così via.
license	Licenza associata a questo suggerimento. Se presente, si riferisce alla licenza della fonte di questa citazione. Le possibili licenze includono licenze di codice, ad esempio mit License.
publicationDate	Data di pubblicazione associata a questa citazione. Se presente, si riferisce alla data in cui è stata pubblicata la fonte di questa citazione. I formati possibili sono AAAA, AAAA-MM, AAAA-MM-GG.
safetyAttributes	Una raccolta di categorie e i relativi punteggi di affidabilità associati. Mappatura 1:1 a candidates.
input_token_count	Numero di token di input. Questo è il numero totale di token in tutti i messaggi, gli esempi e il contesto.
output_token_count	Numero di token di output. Questo è il numero totale di token in content tra tutti i candidati nella risposta.
tokens	I token campionati.
tokenLogProbs	I token campionati registrare le probabilità.
topLogProb	I token candidati più probabili e le relative probabilità di log in ogni passaggio.
logprobs	Risultati del parametro "logprobs". Mappatura 1:1 sui "candidati".

Esempio di risposta

{
  "predictions": [
    {
      "citationMetadata": {
        "citations": []
      },
      "safetyAttributes": {
        "scores": [
          0.1
        ],
        "categories": [
          "Finance"
        ],
        "blocked": false
      },
      "candidates": [
        {
          "author": "AUTHOR",
          "content": "RESPONSE"
        }
      ]
    }
  ]
}

Trasmetti la risposta dai modelli di IA generativa

I parametri sono gli stessi per le richieste di flusso e non di streaming le API.

Per visualizzare richieste di codice e risposte di esempio utilizzando l'API REST, consulta Esempi di utilizzo dell'API REST per lo streaming.

Per visualizzare richieste di codice e risposte di esempio utilizzando l'SDK Vertex AI per Python, consulta Esempi di utilizzo dell'SDK Vertex AI per Python per i flussi.