Coba model Gemini 1.5, model multimodal terbaru di Vertex AI, dan lihat model yang dapat Anda bangun dengan jendela konteks hingga 2 juta token. Coba model Gemini 1.5, model multimodal terbaru di Vertex AI, dan lihat model yang dapat Anda bangun dengan jendela konteks hingga 2 juta token.

Chat teks

Model dasar PaLM 2 untuk Chat (chat-bison) adalah model bahasa besar (LLM) yang andal dalam pemahaman bahasa, pembuatan bahasa, dan percakapan. Model chat ini telah disesuaikan untuk melakukan percakapan multi-giliran yang alami, dan ideal untuk tugas teks tentang kode yang memerlukan interaksi bolak-balik.

Untuk tugas teks yang dapat diselesaikan dengan satu respons API (tanpa memerlukan percakapan bersambung), gunakan Model teks.

Untuk menjelajahi model ini di konsol, lihat kartu model PaLM 2 untuk Chat di Model Garden.
Buka Model Garden

Kasus penggunaan

Layanan Pelanggan: Menginstruksikan model untuk merespons sebagai agen layanan pelanggan yang hanya membahas produk perusahaan Anda
Dukungan Teknis: Menginstruksikan model untuk berinteraksi dengan pelanggan sebagai agen pusat panggilan dengan parameter khusus tentang cara merespons dan hal yang tidak boleh dikatakan
Persona dan karakter: Menginstruksikan model untuk merespons dengan gaya orang tertentu ("...dengan gaya Shakespeare")
Pendamping situs: Membuat asisten percakapan untuk belanja, perjalanan, dan kasus penggunaan lainnya

Untuk mengetahui informasi selengkapnya, lihat Mendesain perintah chat.

Permintaan HTTP

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

Untuk informasi selengkapnya, lihat metode predict.

Versi model

Untuk menggunakan versi model terbaru, tentukan nama model tanpa nomor versi, misalnya chat-bison.

Untuk menggunakan versi model stabil, tentukan nomor versi model, misalnya chat-bison@002. Setiap versi stabil tersedia selama enam bulan setelah tanggal rilis versi stabil berikutnya.

Tabel berikut berisi versi model stabil yang tersedia:

model chat-bison	Tanggal rilis	Tanggal penghentian
chat-bison@002	6 Desember 2023	9 Oktober 2024
chat-bison@001	10 Juli 2023	6 Juli 2024

Untuk mengetahui informasi selengkapnya, baca Versi dan siklus proses model.

Isi permintaan

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

Untuk panggilan API chat, context, examples, dan messages digabungkan untuk membentuk perintah. Tabel berikut menunjukkan parameter yang perlu Anda konfigurasi untuk Vertex AI PaLM API untuk teks:

Parameter	Deskripsi	Nilai yang dapat diterima
`context` (opsional)	Konteks menentukan bagaimana model merespons sepanjang percakapan. Misalnya, Anda dapat menggunakan konteks untuk menentukan kata-kata yang bisa atau tidak dapat digunakan model, topik yang harus difokuskan atau dihindari, atau format atau gaya respons.	Text
`examples` (opsional)	Contoh bagi model untuk mempelajari cara merespons percakapan.	[{ "input": {"content": "provide content"}, "output": {"content": "provide content"} }]
`messages` (wajib)	Histori percakapan yang diberikan kepada model dalam formulir penulis alternatif terstruktur. Pesan muncul dalam urutan kronologis: terlama dulu, terbaru terakhir. Jika histori pesan menyebabkan input melebihi panjang maksimum, pesan yang paling lama akan dihapus hingga seluruh perintah berada dalam batas yang diizinkan.	[{ "author": "user", "content": "user message" }]
`temperature`	Suhu digunakan untuk pengambilan sampel selama pembuatan respons, yang terjadi saat `topP` dan `topK` diterapkan. Suhu mengontrol tingkat keacakan dalam pemilihan token. Suhu yang lebih rendah cocok untuk perintah yang memerlukan respons yang kurang terbuka atau kreatif, sedangkan suhu yang lebih tinggi dapat memberikan hasil yang lebih beragam atau kreatif. Suhu `0` berarti token probabilitas tertinggi selalu dipilih. Dalam hal ini, respons untuk permintaan tertentu sebagian besar deterministik, tetapi sedikit variasi masih dapat dilakukan. Jika model menampilkan respons yang terlalu umum, terlalu pendek, atau model memberikan respons penggantian, coba tingkatkan suhu.	`0.0–1.0` `Default: 0.0`
`maxOutputTokens`	Jumlah maksimum token yang dapat dibuat dalam respons. Token terdiri dari sekitar empat karakter. 100 token setara dengan sekitar 60-80 kata. Tentukan nilai yang lebih rendah untuk respons yang lebih pendek dan nilai yang lebih tinggi untuk respons yang berpotensi lebih lama.	`1–2048` `Default: 1024`
`topK`	Top-K mengubah cara model memilih token untuk output. Top-K `1` berarti token yang dipilih berikutnya adalah yang paling mungkin di antara semua token dalam kosakata model (juga disebut decoding greedy), sedangkan top-K `3` berarti token berikutnya dipilih di antara tiga token yang paling mungkin dengan menggunakan suhu. Untuk setiap langkah pemilihan token, token top-K dengan probabilitas tertinggi akan diambil sampelnya. Kemudian token akan difilter lebih lanjut berdasarkan top-P dengan token akhir yang dipilih menggunakan pengambilan sampel suhu. Tentukan nilai yang lebih rendah untuk respons acak yang lebih sedikit dan nilai yang lebih tinggi untuk respons acak yang lebih banyak.	`1–40` `Default: 40`
`topP`	Top-P mengubah cara model memilih token untuk output. Token dipilih dari yang paling mungkin (lihat top-K) hingga yang paling tidak mungkin sampai jumlah probabilitasnya sama dengan nilai top-P. Misalnya, jika token A, B, dan C memiliki probabilitas 0,3, 0,2, dan 0,1 dengan nilai top-P `0.5`, model akan memilih A atau B sebagai token berikutnya dengan menggunakan suhu dan mengecualikan C sebagai kandidat. Tentukan nilai yang lebih rendah untuk respons acak yang lebih sedikit dan nilai yang lebih tinggi untuk respons acak yang lebih banyak.	`0.0–1.0` `Default: 0.95`
`stopSequences`	Menentukan daftar string yang memberi tahu model untuk berhenti menghasilkan teks jika salah satu string ditemukan dalam respons. Jika string muncul beberapa kali dalam respons, respons akan dipotong di tempatnya pertama kali ditemukan. String peka huruf besar/kecil. Misalnya, jika respons berikut adalah respons yang ditampilkan saat `stopSequences` tidak ditentukan: `public static string reverse(string myString)` Kemudian respons yang ditampilkan dengan `stopSequences` ditetapkan ke `["Str", "reverse"]` adalah: `public static string`	`default: []`
`groundingConfig`	Grounding memungkinkan Anda mereferensikan data tertentu saat menggunakan model bahasa. Saat Anda menempatkan model, model dapat mereferensikan data internal, rahasia, dan spesifik dari repositori Anda serta menyertakan data dalam responsnya. Hanya penyimpanan data dari Vertex AI Search yang didukung.	Jalur harus mengikuti format: `projects/{project_id}/locations/global/collections/{collection_name}/dataStores/{DATA_STORE_ID}`
`candidateCount`	Jumlah variasi respons yang akan ditampilkan.	`1–4` `Default: 1`
`logprobs`	Menampilkan token kandidat `logprobs` teratas yang kemungkinan besar beserta probabilitas lognya pada setiap langkah pembuatan. Token yang dipilih dan probabilitas lognya di setiap langkah akan selalu ditampilkan. Token yang dipilih mungkin termasuk atau tidak termasuk dalam kandidat `logprobs` teratas.	`0-5`
`frequencyPenalty`	Nilai positif akan berdampak terhadap token yang berulang kali muncul dalam teks yang dihasilkan, sehingga mengurangi kemungkinan pengulangan konten. Nilai yang dapat diterima adalah `-2.0`—`2.0`.	`Minimum value: -2.0` `Maximum value: 2.0`
`presencePenalty`	Nilai positif akan merugikan token yang sudah muncul dalam teks yang dihasilkan, sehingga meningkatkan kemungkinan menghasilkan konten yang lebih beragam. Nilai yang dapat diterima adalah `-2.0`—`2.0`.	`Minimum value: -2.0` `Maximum value: 2.0`
`seed`	Decoder menghasilkan derau acak dengan generator angka acak semu, derau suhu * ditambahkan ke logits sebelum pengambilan sampel. Generator angka acak semu (prng) mengambil seed sebagai input, dan menghasilkan output yang sama dengan seed yang sama. Jika seed tidak ditetapkan, seed yang digunakan dalam decoder tidak akan bersifat determenistik, sehingga derau acak yang dihasilkan tidak akan deterministik. Jika seed ditetapkan, derau acak yang dihasilkan akan bersifat deterministik.	`Optional`

Permintaan sampel

REST

Untuk menguji chat teks menggunakan Vertex AI API, kirim permintaan POST ke endpoint model penayang.

Sebelum menggunakan salah satu data permintaan, lakukan penggantian berikut:

PROJECT_ID: Project ID Anda.

Untuk kolom lainnya, lihat tabel Isi permintaan di bawah.

Metode HTTP dan URL:

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

Isi JSON permintaan:

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

Untuk mengirim permintaan Anda, pilih salah satu opsi berikut:

curl

Catatan: Perintah berikut mengasumsikan bahwa Anda telah login ke CLI gcloud dengan akun pengguna Anda dengan menjalankan gcloud init atau gcloud auth login, atau menggunakan Cloud Shell, yang secara otomatis membuat Anda login ke CLI gcloud. Anda dapat memeriksa akun yang aktif saat ini dengan menjalankan gcloud auth list.

Simpan isi permintaan dalam file bernama request.json, dan jalankan perintah berikut:

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

Catatan: Perintah berikut mengasumsikan bahwa Anda telah login ke CLI gcloud dengan akun pengguna Anda dengan menjalankan gcloud init atau gcloud auth login. Anda dapat memeriksa akun yang aktif saat ini dengan menjalankan gcloud auth list.

Simpan isi permintaan dalam file bernama request.json, dan jalankan perintah berikut:

$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

Anda akan menerima respons JSON yang mirip seperti contoh respons.

Python

Untuk mempelajari cara menginstal atau mengupdate Vertex AI SDK untuk Python, lihat Menginstal Vertex AI SDK untuk Python. Untuk mengetahui informasi selengkapnya, lihat dokumentasi referensi Python API.

from vertexai.language_models import ChatModel, InputOutputTextPair

def science_tutoring(temperature: float = 0.2) -> None:
    chat_model = ChatModel.from_pretrained("chat-bison@001")

    # 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.95,  # 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.
    }

    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(f"Response from Model: {response.text}")

    return response

Node.js

Sebelum mencoba contoh ini, ikuti petunjuk penyiapan Node.js di Panduan memulai Vertex AI menggunakan library klien. Untuk mengetahui informasi selengkapnya, lihat Dokumentasi referensi API Node.js Vertex AI.

Untuk melakukan autentikasi ke Vertex AI, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

/**
 * 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

Sebelum mencoba contoh ini, ikuti petunjuk penyiapan Java di Panduan memulai Vertex AI menggunakan library klien. Untuk mengetahui informasi selengkapnya, lihat Dokumentasi referensi API Java Vertex AI.

Untuk melakukan autentikasi ke Vertex AI, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.


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

Isi respons

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

Elemen respons	Deskripsi
`content`	Konten teks pesan chat.
`candidates`	Hasil chat yang dihasilkan dari pesan tertentu.
`categories`	Nama tampilan kategori Atribut Keamanan terkait dengan konten yang dibuat. Urutan cocok dengan Skor.
`author`	Tag penulis untuk giliran.
`scores`	Skor keyakinan setiap kategori, nilai yang lebih tinggi berarti keyakinan yang lebih tinggi.
`blocked`	Flag yang menunjukkan apakah input atau output model diblokir.
`startIndex`	Indeks dalam output prediksi tempat kutipan dimulai (inklusif). Harus >= 0 dan < end_index.
`endIndex`	Indeks dalam output prediksi tempat kutipan berakhir (eksklusif). Harus > start_index dan < len(output).
`url`	URL yang terkait dengan kutipan ini. Jika ada, URL ini akan ditautkan ke halaman web sumber kutipan ini. URL yang memungkinkan mencakup situs berita, repositori GitHub, dll.
`title`	Judul yang terkait dengan kutipan ini. Jika ada, judul tersebut merujuk pada judul sumber kutipan ini. Judul yang memungkinkan mencakup judul berita, judul buku, dll.
`license`	Lisensi yang terkait dengan kutipan ini. Jika ada, lisensi tersebut merujuk pada lisensi sumber kutipan ini. Lisensi yang memungkinkan mencakup lisensi kode, misalnya, lisensi mit.
`publicationDate`	Tanggal terbit yang terkait dengan kutipan ini. Jika ada, tanggal terbit tersebut mengacu pada tanggal sumber kutipan ini dipublikasikan. Format yang memungkinkan adalah YYYY, YYYY-MM, YYYY-MM-DD.
`safetyAttributes`	Kumpulan kategori dan skor keyakinannya yang terkait. Pemetaan 1-1 ke `candidates`.
`input_token_count`	Jumlah token input. Ini adalah jumlah total token di semua pesan, contoh, dan konteks.
`output_token_count`	Jumlah token output. Ini adalah jumlah total token di `content` untuk semua kandidat dalam respons.
`tokens`	Token yang diambil sampelnya.
`tokenLogProbs`	Probabilitas log token yang diambil sampelnya.
`topLogProb`	Token kandidat yang paling mungkin dan probabilitas lognya di setiap langkah.
`logprobs`	Hasil parameter `logprobs`. Pemetaan 1-1 ke `kandidat`.

Contoh respons

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

Streaming respons dari model AI Generatif

Parameternya sama untuk permintaan streaming dan non-streaming ke API.

Untuk melihat contoh permintaan dan respons kode menggunakan REST API, lihat Contoh menggunakan REST API streaming.

Untuk melihat contoh permintaan dan respons kode menggunakan Vertex AI SDK untuk Python, lihat Contoh penggunaan Vertex AI SDK untuk Python untuk streaming.