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.

Halaman ini diterjemahkan oleh Cloud Translation API.

Teks

Model dasar PaLM 2 untuk Teks (text-bison, text-unicorn) dioptimalkan untuk berbagai tugas natural language seperti analisis sentimen, ekstraksi entity, dan pembuatan konten. Jenis konten yang dapat dibuat oleh model PaLM 2 for Text mencakup ringkasan dokumen, jawaban atas pertanyaan, dan label yang mengklasifikasikan konten.

Model PaLM 2 untuk Teks ideal untuk tugas yang dapat diselesaikan dengan satu respons API, tanpa perlu percakapan berkelanjutan. Untuk tugas teks yang memerlukan interaksi dua arah, gunakan AI Generatif di Vertex AI API untuk chat.

Untuk menjelajahi model di konsol, pilih kartu model PaLM 2 for Text di Model Garden.
Buka Model Garden

Kasus penggunaan

Ringkasan: Membuat versi dokumen yang lebih pendek yang menggabungkan informasi terkait dari teks asli. Misalnya, Anda mungkin ingin meringkas bab dari buku teks. Atau, Anda dapat membuat deskripsi produk singkat dari paragraf panjang yang menjelaskan produk secara mendetail.
Penjawaban pertanyaan: Memberikan jawaban atas pertanyaan dalam teks. Misalnya, Anda dapat mengotomatiskan pembuatan dokumen Pertanyaan Umum (FAQ) dari konten pusat informasi.
Klasifikasi: Menetapkan label ke teks yang disediakan. Misalnya, label mungkin diterapkan pada teks yang menjelaskan seberapa benar tata bahasa teks tersebut.
Analisis sentimen: Ini adalah bentuk klasifikasi yang mengidentifikasi sentimen teks. Sentimen diubah menjadi label yang diterapkan ke teks. Misalnya, sentimen teks mungkin berupa polaritas seperti positif atau negatif, atau sentimen seperti kemarahan atau kebahagiaan.
Ekstraksi entity: Mengekstrak informasi dari teks. Misalnya, Anda dapat mengekstrak nama film dari teks sebuah artikel.

Untuk mengetahui informasi selengkapnya tentang cara mendesain perintah teks, lihat Mendesain perintah teks.

Permintaan HTTP

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

Lihat metode predict untuk informasi selengkapnya.

Versi model

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

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

Tabel berikut berisi versi model stabil yang tersedia:

model teks-bison	Tanggal rilis	Tanggal penghentian
text-bison@002	6 Desember 2023	9 April 2025

model text-unicorn	Tanggal rilis	Tanggal penghentian
text-unicorn@001	30 November 2023	9 April 2025

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

Isi permintaan

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

Gunakan parameter berikut untuk model teks text-bison. Untuk mengetahui informasi selengkapnya, lihat Mendesain perintah teks.

Parameter	Deskripsi	Nilai yang dapat diterima
`prompt`	Input teks untuk menghasilkan respons model. Perintah dapat mencakup preamble, pertanyaan, saran, petunjuk, atau contoh.	Teks
`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 pengganti, coba tingkatkan suhunya.	`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 singkat dan nilai yang lebih tinggi untuk respons yang berpotensi lebih panjang.	`1–2048` untuk text-bison (terbaru) `1–1024` untuk text-bison@002 `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`
`stopSequence`	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`	Pembumian memungkinkan Anda mereferensikan data tertentu saat menggunakan model bahasa. Saat Anda mendasari model, model tersebut dapat mereferensikan data internal, rahasia, dan data spesifik lainnya dari repositori Anda dan menyertakan data dalam respons. Hanya penyimpanan data dari Vertex AI Search yang didukung.	Jalur harus mengikuti format: `projects/{project_number_or_id}/locations/global/collections/{collection_name}/dataStores/{DATA_STORE_ID}`
`candidateCount`	Jumlah variasi respons yang akan ditampilkan. Untuk setiap permintaan, Anda dikenai biaya untuk token output dari semua kandidat, tetapi hanya dikenai biaya satu kali untuk token input. Menentukan beberapa kandidat adalah fitur Pratinjau yang berfungsi dengan `generateContent` (`streamGenerateContent` tidak didukung). Model berikut didukung: Gemini 1.5 Flash: `1`-`8`, default: `1` Gemini 1.5 Pro: `1`-`8`, default: `1` Gemini 1.0 Pro: `1`-`8`, default: `1`	`1–4` `Default: 1`
`logprobs`	Menampilkan log probabilitas token kandidat teratas pada setiap langkah pembuatan. Token yang dipilih model mungkin tidak sama dengan token kandidat teratas di setiap langkah. Tentukan jumlah kandidat yang akan ditampilkan menggunakan nilai bilangan bulat dalam rentang `1`-`5`.	`0-5`
`frequencyPenalty`	Nilai positif akan menghukum token yang berulang kali muncul dalam teks yang dihasilkan, sehingga mengurangi kemungkinan konten berulang. Nilai minimumnya adalah `-2.0`. Nilai maksimumnya adalah hingga, tetapi tidak termasuk, `2.0`.	`Minimum value: -2.0` `Maximum value: 2.0`
`presencePenalty`	Nilai positif akan menghukum token yang sudah muncul dalam teks yang dihasilkan, sehingga meningkatkan probabilitas untuk menghasilkan konten yang lebih beragam. Nilai minimumnya adalah `-2.0`. Nilai maksimumnya adalah hingga, tetapi tidak termasuk, `2.0`.	`Minimum value: -2.0` `Maximum value: 2.0`
`echo`	Jika benar, perintah akan diulang dalam teks yang dihasilkan.	`Optional`
`seed`	Jika seed ditetapkan ke nilai tertentu, model akan berusaha sebaik mungkin untuk memberikan respons yang sama untuk permintaan berulang. Output deterministik tidak dijamin. Selain itu, mengubah setelan model atau parameter, seperti suhu, dapat menyebabkan variasi respons meskipun Anda menggunakan nilai seed yang sama. Secara default, nilai seed acak akan digunakan. Ini adalah fitur pratinjau.	`Optional`

Permintaan sampel

REST

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

Sebelum menggunakan data permintaan mana pun, lakukan penggantian berikut:

PROJECT_ID: Project ID Anda.

Untuk kolom lainnya, lihat tabel Isi permintaan.

Metode HTTP dan URL:

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

Isi JSON permintaan:

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

Untuk mengirim permintaan Anda, pilih salah satu opsi berikut:

curl

Catatan: Perintah berikut mengasumsikan bahwa Anda telah login ke gcloud CLI dengan akun pengguna Anda dengan menjalankan gcloud init atau gcloud auth login , atau dengan menggunakan Cloud Shell, yang secara otomatis membuat Anda login ke gcloud CLI . Anda dapat memeriksa akun yang saat ini aktif 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/text-bison:predict"

PowerShell

Catatan: Perintah berikut mengasumsikan bahwa Anda telah login ke gcloud CLI dengan akun pengguna Anda dengan menjalankan gcloud init atau gcloud auth login . Anda dapat memeriksa akun yang saat ini aktif 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/text-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.

import vertexai

from vertexai.language_models import TextGenerationModel

# TODO(developer): Update and un-comment below line
# PROJECT_ID = "your-project-id"
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}")
# Example response:
# Response from Model:  1. **Tell me about your experience managing programs.**
# 2. **What are your strengths and weaknesses as a program manager?**
# 3. **What do you think are the most important qualities for a successful program manager?**
# ...

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): 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

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

Isi respons

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

Elemen respons	Deskripsi
`content`	Hasil yang dihasilkan dari teks input.
`categories`	Nama tampilan kategori Atribut Keamanan terkait dengan konten yang dibuat. Urutan cocok dengan Skor.
`scores`	Skor keyakinan setiap kategori, nilai yang lebih tinggi berarti keyakinan yang lebih tinggi.
`blocked`	Flag yang menunjukkan apakah input atau output model diblokir.
`errors`	Kode error yang mengidentifikasi alasan input atau output diblokir. Untuk mengetahui daftar kode error, lihat Filter dan atribut keamanan.
`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.
`input_token_count`	Jumlah token input. Ini adalah jumlah total token di seluruh perintah, awalan, dan akhiran.
`output_token_count`	Jumlah token output. Ini adalah jumlah total token dalam `content` di seluruh prediksi.
`tokens`	Token sampel.
`tokenLogProbs`	Probabilitas log token sampel.
`topLogProb`	Token kandidat yang paling mungkin dan probabilitas lognya di setiap langkah.
`logprobs`	Hasil parameter `logprobs`. Pemetaan 1-1 ke `candidates`.

Contoh respons

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

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.

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