Menyesuaikan embedding teks

Panduan ini menunjukkan cara menyesuaikan model embedding teks untuk meningkatkan performa tugas spesifik Anda. Panduan ini mencakup topik berikut:

Model embedding dasar dilatih sebelumnya dengan set data teks yang besar, yang memberikan dasar yang kuat untuk banyak tugas. Untuk skenario yang memerlukan pengetahuan khusus atau performa yang sangat disesuaikan, Anda dapat menggunakan penyesuaian model untuk meningkatkan kualitas representasi model dengan data Anda sendiri. Penyesuaian didukung untuk versi stabil dari model textembedding-gecko dan textembedding-gecko-multilingual.

Model embedding teks mendukung penyesuaian yang diawasi. Penyesuaian yang diawasi menggunakan contoh berlabel yang menunjukkan jenis output yang Anda inginkan dari model penyematan teks selama inferensi.

Untuk mempelajari penyesuaian model lebih lanjut, lihat Cara kerja penyesuaian model.

Peningkatan kualitas yang diharapkan

Vertex AI menggunakan metode penyesuaian yang hemat parameter untuk penyesuaian. Metode ini menunjukkan peningkatan kualitas yang signifikan hingga 41% (rata-rata 12%) pada eksperimen yang dilakukan pada set data tolok ukur pengambilan publik.

Kasus penggunaan untuk menyesuaikan model embedding

Menyesuaikan model embedding teks membantu mengadaptasi model ke domain atau tugas tertentu. Hal ini berguna saat model terlatih tidak sesuai dengan kebutuhan Anda. Misalnya, menyesuaikan model embedding pada tiket dukungan pelanggan perusahaan Anda dapat membantu chatbot lebih memahami masalah umum dan menjawab pertanyaan secara lebih efektif. Tanpa penyesuaian, model tidak memiliki pengetahuan spesifik tentang tiket dukungan dan solusi produk Anda.

Alur kerja penyesuaian

Alur kerja penyesuaian model di Vertex AI untuk textembedding-gecko dan textembedding-gecko-multilingual mencakup langkah-langkah berikut:

  1. Siapkan set data penyesuaian model Anda.
  2. Upload set data penyesuaian model ke bucket Cloud Storage.
  3. Konfigurasi project Anda untuk Vertex AI Pipelines.
  4. Buat tugas penyesuaian model.

Setelah tugas penyesuaian selesai, model yang disesuaikan akan ditambahkan ke Model Registry. Tidak seperti tugas penyesuaian model lainnya, tugas penyesuaian embedding teks tidak otomatis men-deploy model ke endpoint. Anda harus men-deploy model yang telah disesuaikan secara manual.

Menyiapkan set data embedding

Set data yang Anda gunakan untuk menyesuaikan model embedding menyertakan data yang selaras dengan tugas yang Anda inginkan untuk dilakukan oleh model.

Format set data untuk menyesuaikan model embedding

Set data pelatihan terdiri dari file berikut, yang harus berada di Cloud Storage. Anda menentukan jalur untuk setiap file dengan parameter saat meluncurkan pipeline penyesuaian.

  • File korpus: Jalur ditentukan oleh parameter corpus_path. Ini adalah file JSONL yang setiap barisnya memiliki kolom _id, title, dan text dengan nilai string. _id dan text wajib ada, sedangkan title bersifat opsional. Berikut adalah contoh file corpus.jsonl:

    {"_id": "doc1", "title": "Get an introduction to generative AI on Vertex AI", "text": "Vertex AI Studio offers a Google Cloud console tool for rapidly prototyping and testing generative AI models. Learn how you can use Vertex AI Studio to test models using prompt samples, design and save prompts, tune a foundation model, and convert between speech and text."}
{"_id": "doc2", "title": "Use gen AI for summarization, classification, and extraction", "text": "Learn how to create text prompts for handling any number of tasks with Vertex AI's generative AI support. Some of the most common tasks are classification, summarization, and extraction. Vertex AI's PaLM API for text lets you design prompts with flexibility in terms of their structure and format."}
{"_id": "doc3", "title": "Custom ML training overview and documentation", "text": "Get an overview of the custom training workflow in Vertex AI, the benefits of custom training, and the various training options that are available. This page also details every step involved in the ML training workflow from preparing data to predictions."}
{"_id": "doc4", "text": "Text embeddings are useful for clustering, information retrieval, retrieval-augmented generation (RAG), and more."}
{"_id": "doc5", "title": "Text embedding tuning", "text": "Google's text embedding models can be tuned on Vertex AI."}

  • File kueri: Jalur ditentukan oleh parameter queries_path. File kueri berisi contoh kueri Anda, menggunakan format JSONL, dan memiliki kolom yang sama dengan file korpus. Berikut adalah contoh file queries.jsonl:

    {"_id": "query1", "text": "Does Vertex support generative AI?"}
{"_id": "query2", "text": "What can I do with Vertex GenAI offerings?"}
{"_id": "query3", "text": "How do I train my models using Vertex?"}
{"_id": "query4", "text": "What is a text embedding?"}
{"_id": "query5", "text": "Can text embedding models be tuned on Vertex?"}
{"_id": "query6", "text": "embeddings"}
{"_id": "query7", "text": "embeddings for rag"}
{"_id": "query8", "text": "custom model training"}
{"_id": "query9", "text": "Google Cloud PaLM API"}

  • Label pelatihan: Jalur ditentukan oleh parameter train_label_path, yang merupakan Cloud Storage URI ke data label pelatihan. Label harus berada dalam file TSV dengan header. File label pelatihan Anda harus menyertakan subset kueri dan korpus. File harus memiliki kolom query-id, corpus-id, dan score.

    • query-id: String yang cocok dengan kunci _id dari file kueri.
    • corpus-id: String yang cocok dengan kunci _id di file korpus.
    • score: Bilangan bulat non-negatif. Skor yang lebih besar dari 0 menunjukkan bahwa dokumen tersebut terkait dengan kueri. Skor yang lebih tinggi menunjukkan relevansi yang lebih besar. Jika skor tidak ada, nilai defaultnya adalah 1. Jika pasangan kueri dan dokumen tidak terkait, Anda dapat menghapusnya dari file label atau menyertakannya dengan skor 0.

    Berikut adalah contoh file train_labels.tsv:

    query-id    corpus-id   score
query1  doc1    1
query2  doc2    1
query3  doc3    2
query3  doc5  1
query4  doc4  1
query4  doc5  1
query5  doc5  2
query6  doc4  1
query6  doc5  1
query7  doc4  1
query8  doc3  1
query9  doc2  1

  • Label pengujian (Opsional): Label pengujian memiliki format yang sama dengan label pelatihan. Anda menentukannya dengan parameter test_label_path. Jika Anda tidak memberikan test_label_path, label pengujian akan otomatis dipisahkan dari label pelatihan.

  • Label validasi (Opsional): Label validasi memiliki format yang sama dengan label pelatihan. Anda menentukannya dengan parameter validation_label_path. Jika Anda tidak memberikan validation_label_path, label validasi akan otomatis dipisahkan dari label pelatihan.

Persyaratan ukuran set data

File set data yang diberikan harus memenuhi batasan berikut:

  • Jumlah kueri adalah antara 9 dan 10.000.
  • Jumlah dokumen dalam korpus adalah antara 9 dan 500.000.
  • Setiap file label set data menyertakan minimal 3 ID kueri, dan di semua pemisahan set data terdapat minimal 9 ID kueri.
  • Jumlah total label kurang dari 500.000.

Mengonfigurasi project Anda untuk Vertex AI Pipelines

Anda menjalankan tugas penyetelan di project menggunakan platform Vertex AI Pipelines.

Mengonfigurasi izin

Pipeline menjalankan kode pelatihan di bawah dua agen layanan. Anda harus memberikan peran tertentu kepada agen layanan ini untuk menjalankan pelatihan menggunakan project dan set data Anda.

  • Akun layanan default Compute Engine PROJECT_NUMBER-compute@developer.gserviceaccount.com Akun layanan ini memerlukan izin berikut:

    • Storage Object Viewer akses ke setiap file set data yang Anda buat di Cloud Storage.
    • akses Storage Object User ke direktori Cloud Storage output pipeline Anda, PIPELINE_OUTPUT_DIRECTORY.
    • Vertex AI User akses ke project Anda.

    Sebagai pengganti akun layanan default Compute Engine, Anda dapat menentukan akun layanan kustom. Untuk mengetahui informasi selengkapnya, lihat Mengonfigurasi akun layanan dengan izin terperinci.

  • Agen Layanan Penyesuaian Vertex AI service-PROJECT_NUMBER@gcp-sa-aiplatform-ft.iam.gserviceaccount.com Akun layanan ini memerlukan izin berikut:

    • Storage Object Viewer akses ke setiap file set data yang Anda buat di Cloud Storage.
    • akses Storage Object User ke direktori Cloud Storage output pipeline Anda, PIPELINE_OUTPUT_DIRECTORY.

Untuk mengetahui informasi selengkapnya tentang cara mengonfigurasi izin set data Cloud Storage, lihat Mengonfigurasi bucket Cloud Storage untuk artefak pipeline.

Menggunakan akselerator

Penyesuaian memerlukan akselerator GPU. Anda dapat menggunakan salah satu akselerator berikut untuk pipeline penyesuaian embedding teks:

  • NVIDIA_L4
  • NVIDIA_TESLA_A100
  • NVIDIA_TESLA_T4
  • NVIDIA_TESLA_V100
  • NVIDIA_TESLA_P100

Untuk meluncurkan tugas penyesuaian, Anda memerlukan kuota Restricted image training GPUs yang memadai untuk jenis akselerator dan region yang telah Anda pilih, misalnya Restricted image training Nvidia V100 GPUs per region. Untuk meningkatkan kuota project Anda, lihat Meminta kuota tambahan.

Tidak semua akselerator tersedia di semua wilayah. Untuk mengetahui informasi selengkapnya, lihat Menggunakan akselerator di Vertex AI.

Membuat tugas penyesuaian model embedding

Anda dapat membuat tugas penyesuaian model sematan menggunakan konsol Google Cloud , REST API, atau library klien.

REST

Untuk membuat tugas penyesuaian model embedding, gunakan metode projects.locations.pipelineJobs.create.

Sebelum menggunakan salah satu data permintaan, lakukan penggantian berikut:

  • PROJECT_ID: ID project Google Cloud Anda.
  • PIPELINE_OUTPUT_DIRECTORY: Jalur untuk artefak output pipeline, dimulai dengan "gs://".

Metode HTTP dan URL: 

POST https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/pipelineJobs

Meminta isi JSON: 

{
  "displayName": "tune_text_embeddings_model_sample",
  "runtimeConfig": {
    "gcsOutputDirectory": "PIPELINE_OUTPUT_DIRECTORY",
    "parameterValues": {
      "corpus_path": "gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/corpus.jsonl",
      "queries_path": "gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/queries.jsonl",
      "train_label_path": "gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/train.tsv",
      "test_label_path": "gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/test.tsv",
      "base_model_version_id":"text-embedding-004",
      "task_type": "DEFAULT",
      "batch_size": "128",
      "train_steps": "1000",
      "output_dimensionality": "768",
      "learning_rate_multiplier": "1.0"
    }
  },
  "templateUri": "https://us-kfp.pkg.dev/ml-pipeline/llm-text-embedding/tune-text-embedding-model/v1.1.3"
}

Untuk mengirim permintaan Anda, perluas salah satu opsi berikut:

Anda akan menerima respons JSON yang mirip dengan yang berikut ini:

Setelah meluncurkan pipeline, ikuti progres tugas penyesuaian Anda melalui konsolGoogle Cloud .

Buka Google Cloud konsol

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 API Python. 

import re

from google.cloud.aiplatform import initializer as aiplatform_init
from vertexai.language_models import TextEmbeddingModel


def tune_embedding_model(
    api_endpoint: str,
    base_model_name: str = "text-embedding-005",
    corpus_path: str = "gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/corpus.jsonl",
    queries_path: str = "gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/queries.jsonl",
    train_label_path: str = "gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/train.tsv",
    test_label_path: str = "gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/test.tsv",
):  # noqa: ANN201
    """Tune an embedding model using the specified parameters.
    Args:
        api_endpoint (str): The API endpoint for the Vertex AI service.
        base_model_name (str): The name of the base model to use for tuning.
        corpus_path (str): GCS URI of the JSONL file containing the corpus data.
        queries_path (str): GCS URI of the JSONL file containing the queries data.
        train_label_path (str): GCS URI of the TSV file containing the training labels.
        test_label_path (str): GCS URI of the TSV file containing the test labels.
    """
    match = re.search(r"^(\w+-\w+)", api_endpoint)
    location = match.group(1) if match else "us-central1"
    base_model = TextEmbeddingModel.from_pretrained(base_model_name)
    tuning_job = base_model.tune_model(
        task_type="DEFAULT",
        corpus_data=corpus_path,
        queries_data=queries_path,
        training_data=train_label_path,
        test_data=test_label_path,
        batch_size=128,  # The batch size to use for training.
        train_steps=1000,  # The number of training steps.
        tuned_model_location=location,
        output_dimensionality=768,  # The dimensionality of the output embeddings.
        learning_rate_multiplier=1.0,  # The multiplier for the learning rate.
    )
    return tuning_job

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, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal. 

import com.google.cloud.aiplatform.v1.CreatePipelineJobRequest;
import com.google.cloud.aiplatform.v1.LocationName;
import com.google.cloud.aiplatform.v1.PipelineJob;
import com.google.cloud.aiplatform.v1.PipelineJob.RuntimeConfig;
import com.google.cloud.aiplatform.v1.PipelineServiceClient;
import com.google.cloud.aiplatform.v1.PipelineServiceSettings;
import com.google.protobuf.Value;
import java.io.IOException;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class EmbeddingModelTuningSample {
  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running this sample.
    String apiEndpoint = "us-central1-aiplatform.googleapis.com:443";
    String project = "PROJECT";
    String baseModelVersionId = "BASE_MODEL_VERSION_ID";
    String taskType = "DEFAULT";
    String pipelineJobDisplayName = "PIPELINE_JOB_DISPLAY_NAME";
    String outputDir = "OUTPUT_DIR";
    String queriesPath = "QUERIES_PATH";
    String corpusPath = "CORPUS_PATH";
    String trainLabelPath = "TRAIN_LABEL_PATH";
    String testLabelPath = "TEST_LABEL_PATH";
    double learningRateMultiplier = 1.0;
    int outputDimensionality = 768;
    int batchSize = 128;
    int trainSteps = 1000;

    createEmbeddingModelTuningPipelineJob(
        apiEndpoint,
        project,
        baseModelVersionId,
        taskType,
        pipelineJobDisplayName,
        outputDir,
        queriesPath,
        corpusPath,
        trainLabelPath,
        testLabelPath,
        learningRateMultiplier,
        outputDimensionality,
        batchSize,
        trainSteps);
  }

  public static PipelineJob createEmbeddingModelTuningPipelineJob(
      String apiEndpoint,
      String project,
      String baseModelVersionId,
      String taskType,
      String pipelineJobDisplayName,
      String outputDir,
      String queriesPath,
      String corpusPath,
      String trainLabelPath,
      String testLabelPath,
      double learningRateMultiplier,
      int outputDimensionality,
      int batchSize,
      int trainSteps)
      throws IOException {
    Matcher matcher = Pattern.compile("^(?<Location>\\w+-\\w+)").matcher(apiEndpoint);
    String location = matcher.matches() ? matcher.group("Location") : "us-central1";
    String templateUri =
        "https://us-kfp.pkg.dev/ml-pipeline/llm-text-embedding/tune-text-embedding-model/v1.1.4";
    PipelineServiceSettings settings =
        PipelineServiceSettings.newBuilder().setEndpoint(apiEndpoint).build();
    try (PipelineServiceClient client = PipelineServiceClient.create(settings)) {
      Map<String, Value> parameterValues =
          Map.of(
              "base_model_version_id", valueOf(baseModelVersionId),
              "task_type", valueOf(taskType),
              "queries_path", valueOf(queriesPath),
              "corpus_path", valueOf(corpusPath),
              "train_label_path", valueOf(trainLabelPath),
              "test_label_path", valueOf(testLabelPath),
              "learning_rate_multiplier", valueOf(learningRateMultiplier),
              "output_dimensionality", valueOf(outputDimensionality),
              "batch_size", valueOf(batchSize),
              "train_steps", valueOf(trainSteps));
      PipelineJob pipelineJob =
          PipelineJob.newBuilder()
              .setTemplateUri(templateUri)
              .setDisplayName(pipelineJobDisplayName)
              .setRuntimeConfig(
                  RuntimeConfig.newBuilder()
                      .setGcsOutputDirectory(outputDir)
                      .putAllParameterValues(parameterValues)
                      .build())
              .build();
      CreatePipelineJobRequest request =
          CreatePipelineJobRequest.newBuilder()
              .setParent(LocationName.of(project, location).toString())
              .setPipelineJob(pipelineJob)
              .build();
      return client.createPipelineJob(request);
    }
  }

  private static Value valueOf(String s) {
    return Value.newBuilder().setStringValue(s).build();
  }

  private static Value valueOf(int n) {
    return Value.newBuilder().setNumberValue(n).build();
  }

  private static Value valueOf(double n) {
    return Value.newBuilder().setNumberValue(n).build();
  }
}

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, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal. 

async function main(
  apiEndpoint,
  project,
  outputDir,
  pipelineJobDisplayName = 'embedding-customization-pipeline-sample',
  baseModelVersionId = 'text-embedding-005',
  taskType = 'DEFAULT',
  corpusPath = 'gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/corpus.jsonl',
  queriesPath = 'gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/queries.jsonl',
  trainLabelPath = 'gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/train.tsv',
  testLabelPath = 'gs://cloud-samples-data/ai-platform/embedding/goog-10k-2024/r11/test.tsv',
  outputDimensionality = 768,
  learningRateMultiplier = 1.0,
  batchSize = 128,
  trainSteps = 1000
) {
  const aiplatform = require('@google-cloud/aiplatform');
  const {PipelineServiceClient} = aiplatform.v1;
  const {helpers} = aiplatform; // helps construct protobuf.Value objects.

  const client = new PipelineServiceClient({apiEndpoint});
  const match = apiEndpoint.match(/(?<L>\w+-\w+)/);
  const location = match ? match.groups.L : 'us-central1';
  const parent = `projects/${project}/locations/${location}`;
  const params = {
    base_model_version_id: baseModelVersionId,
    task_type: taskType,
    queries_path: queriesPath,
    corpus_path: corpusPath,
    train_label_path: trainLabelPath,
    test_label_path: testLabelPath,
    batch_size: batchSize,
    train_steps: trainSteps,
    output_dimensionality: outputDimensionality,
    learning_rate_multiplier: learningRateMultiplier,
  };
  const runtimeConfig = {
    gcsOutputDirectory: outputDir,
    parameterValues: Object.fromEntries(
      Object.entries(params).map(([k, v]) => [k, helpers.toValue(v)])
    ),
  };
  const pipelineJob = {
    templateUri:
      'https://us-kfp.pkg.dev/ml-pipeline/llm-text-embedding/tune-text-embedding-model/v1.1.4',
    displayName: pipelineJobDisplayName,
    runtimeConfig,
  };
  async function createTuneJob() {
    const [response] = await client.createPipelineJob({parent, pipelineJob});
    console.log(`job_name: ${response.name}`);
    console.log(`job_state: ${response.state}`);
  }

  await createTuneJob();
}

Konsol

Untuk menyesuaikan model embedding teks menggunakan konsol Google Cloud , Anda dapat meluncurkan pipeline penyesuaian menggunakan langkah-langkah berikut:

  1. Di bagian Vertex AI pada konsol Google Cloud , buka halaman Vertex AI Pipelines.

    Buka Vertex AI Pipelines

  2. Klik Create run untuk membuka panel Create pipeline run.
  3. Klik Pilih dari pipeline yang ada dan masukkan detail berikut:
    1. Pilih "ml-pipeline" dari drop-down select a resource.
    2. Pilih "llm-text-embedding" dari drop-down Repository.
    3. Pilih "tune-text-embedding-model" dari drop-down Pipeline atau komponen.
    4. Pilih versi berlabel "v1.1.3" dari drop-down Version.
  4. Tentukan Run name untuk mengidentifikasi operasi pipeline secara unik.
  5. Di menu drop-down Region, pilih region untuk membuat proses pipeline, yang akan menjadi region yang sama dengan tempat model yang di-tuning dibuat.
  6. Klik Lanjutkan. Panel Konfigurasi runtime akan muncul.
  7. Di bagian Lokasi Cloud Storage, klik Cari untuk memilih bucket Cloud Storage guna menyimpan artefak output pipeline, lalu klik Pilih.
  8. Di bagian Parameter pipeline, tentukan parameter untuk pipeline penyesuaian. Tiga parameter yang diperlukan adalah corpus_path, queries_path, dan train_label_path, dengan format yang dijelaskan dalam Menyiapkan set data embedding. Untuk informasi yang lebih mendetail tentang setiap parameter, lihat tab REST di bagian ini.
  9. Klik Submit untuk membuat operasi pipeline.

Fitur lainnya yang didukung

Penyesuaian embedding teks mendukung Kontrol Layanan VPC. Untuk menjalankan tugas penyetelan dalam Virtual Private Cloud (VPC), teruskan parameter network saat Anda membuat PipelineJob.

Untuk menggunakan CMEK (kunci enkripsi yang dikelola pelanggan), teruskan kunci ke parameter pipeline parameterValues.encryption_spec_key_name dan parameter encryptionSpec.kmsKeyName saat Anda membuat PipelineJob.

Menggunakan model yang disesuaikan

Melihat model yang disesuaikan di Model Registry

Saat tugas penyesuaian selesai, model yang disesuaikan tidak otomatis di-deploy ke endpoint. Anda dapat menemukan model yang disesuaikan sebagai resource Model di Model Registry. Anda dapat melihat daftar model dalam project saat ini, termasuk model yang disesuaikan, menggunakan konsol Google Cloud .

Untuk melihat model yang disesuaikan di konsol Google Cloud , buka halaman Vertex AI Model Registry.

Buka Vertex AI Model Registry

Deploy model Anda

Setelah menyesuaikan model embedding, Anda harus men-deploy resource Model. Untuk men-deploy model embedding yang disesuaikan, lihat Men-deploy model ke endpoint.

Tidak seperti model dasar, Anda mengelola model embedding teks yang disesuaikan. Hal ini termasuk mengelola resource aktif, seperti jenis mesin dan akselerator. Untuk mencegah error kehabisan memori selama prediksi, sebaiknya deploy menggunakan jenis GPU NVIDIA_TESLA_A100, yang dapat mendukung ukuran batch hingga 5 untuk panjang input apa pun.

Mirip dengan model dasar textembedding-gecko, model yang disesuaikan mendukung hingga 3.072 token dan dapat memotong input yang lebih panjang.

Mendapatkan prediksi pada model yang di-deploy

Setelah model yang di-tune di-deploy, Anda dapat menggunakan salah satu perintah berikut untuk mengirim permintaan ke endpoint model yang di-tune.

Contoh perintah curl untuk model textembedding-gecko@001 yang telah disesuaikan

Untuk mendapatkan prediksi dari versi textembedding-gecko@001 yang di-tuning, gunakan perintah curl berikut.

PROJECT_ID=PROJECT_ID
LOCATION=LOCATION
ENDPOINT_URI=https://${LOCATION}-aiplatform.googleapis.com
MODEL_ENDPOINT=TUNED_MODEL_ENDPOINT_ID

curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json"  \
    ${ENDPOINT_URI}/v1/projects/${PROJECT_ID}/locations/${LOCATION}/endpoints/${MODEL_ENDPOINT}:predict \
    -d '{
  "instances": [
    {
      "content": "Dining in New York City"
    },
    {
      "content": "Best resorts on the east coast"
    }
  ]
}'

Contoh perintah curl untuk model lain

Versi yang di-tune dari model lain (misalnya, textembedding-gecko@003 dan textembedding-gecko-multilingual@001) memerlukan dua input tambahan: task_type dan title. Untuk mengetahui informasi selengkapnya tentang parameter ini, lihat perintah curl.

PROJECT_ID=PROJECT_ID
LOCATION=LOCATION
ENDPOINT_URI=https://${LOCATION}-aiplatform.googleapis.com
MODEL_ENDPOINT=TUNED_MODEL_ENDPOINT_ID

curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json"  \
    ${ENDPOINT_URI}/v1/projects/${PROJECT_ID}/locations/${LOCATION}/endpoints/${MODEL_ENDPOINT}:predict \
    -d '{
  "instances": [
    {
      "content": "Dining in New York City",
      "task_type": "DEFAULT",
      "title": ""
    },
    {
      "content": "There are many resorts to choose from on the East coast...",
      "task_type": "RETRIEVAL_DOCUMENT",
      "title": "East Coast Resorts"
    }
  ]
}'

Contoh output

Output ini berlaku untuk model textembedding-gecko dan textembedding-gecko-multilingual, terlepas dari versinya.

{
 "predictions": [
   [ ... ],
   [ ... ],
   ...
 ],
 "deployedModelId": "...",
 "model": "projects/.../locations/.../models/...",
 "modelDisplayName": "tuned-text-embedding-model",
 "modelVersionId": "1"
}

Langkah berikutnya