Menyesuaikan embedding teks

Halaman ini menunjukkan cara menyesuaikan model penyematan teks seperti textembedding-gecko dan textembedding-gecko-multilingual.

Model penyematan dasar telah dilatih sebelumnya pada set data teks yang masif, yang memberikan dasar pengukuran yang kuat untuk banyak tugas. Untuk skenario yang memerlukan pengetahuan khusus atau performa yang sangat disesuaikan, penyesuaian model memungkinkan Anda menyesuaikan representasi model menggunakan data Anda sendiri yang relevan. Penyesuaian didukung untuk versistabil 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 parameter yang efisien untuk penyesuaian. Metodologi ini menunjukkan peningkatan kualitas yang signifikan hingga 41% (rata-rata 12%) pada eksperimen yang dilakukan pada set data benchmark pengambilan publik.

Kasus penggunaan untuk menyesuaikan model embedding

Dengan menyesuaikan model embedding teks, model Anda dapat beradaptasi dengan embedding ke domain atau tugas tertentu. Hal ini dapat berguna jika model embedding terlatih tidak sesuai dengan kebutuhan spesifik Anda. Misalnya, Anda dapat menyesuaikan model embedding pada set data tertentu tiket dukungan pelanggan untuk perusahaan Anda. Hal ini dapat membantu chatbot memahami berbagai jenis masalah dukungan pelanggan yang biasanya dialami pelanggan Anda, dan dapat menjawab pertanyaan mereka dengan lebih efektif. Tanpa melakukan penyesuaian, model tidak mengetahui detail tiket dukungan pelanggan atau solusi masalah tertentu untuk produk Anda.

Alur kerja penyesuaian

Alur kerja penyesuaian model di Vertex AI untuk textembedding-gecko dan textembedding-gecko-multilingual adalah sebagai berikut:

  • Siapkan set data penyesuaian model Anda.
  • Upload set data penyesuaian model ke bucket Cloud Storage.
  • Konfigurasikan project Anda untuk Vertex AI Pipelines.
  • Buat tugas penyesuaian model.
  • Deploy model yang disesuaikan ke endpoint Vertex AI dengan nama yang sama. Tidak seperti tugas penyesuaian model teks atau Codey, tugas penyesuaian embedding teks tidak men-deploy model yang disesuaikan ke endpoint Vertex AI.

Menyiapkan set data embedding

Set data yang digunakan 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. Jalur file ditentukan oleh parameter saat meluncurkan pipeline penyesuaian. Tiga jenis file tersebut adalah file korpus, file kueri, dan label. Hanya label pelatihan yang diperlukan, tetapi Anda juga dapat memberikan label validasi dan pengujian untuk kontrol yang lebih besar.

  • 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: File kueri berisi contoh kueri Anda. Jalur ditentukan oleh parameter queries_path. File kueri 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. Train_label_path adalah Cloud Storage URI ke lokasi data label pelatihan dan ditentukan saat Anda membuat tugas penyesuaian. Label harus berupa file TSV dengan header. Subset kueri dan korpus perlu disertakan dalam file label pelatihan Anda. File tersebut harus memiliki kolom query-id, corpus-id, dan score. query-id adalah string yang cocok dengan kunci _id dari file kueri, corpus-id adalah string yang cocok dengan _id di file korpus. Score adalah nilai bilangan bulat non-negatif. Jika sepasang kueri dan dokumen tidak terkait, Anda dapat menghapusnya dari file label pelatihan, atau menyertakannya dengan skor nol. Setiap skor yang lebih besar dari nol menunjukkan bahwa dokumen tersebut terkait dengan kueri. Angka yang lebih besar menunjukkan tingkat relevansi yang lebih besar. Jika skor dihilangkan, nilai defaultnya adalah 1. 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 dan ditentukan oleh parameter test_label_path. Jika tidak ada test_label_path yang diberikan, label pengujian akan otomatis dipisahkan dari label pelatihan.

  • Label validasi: Opsional. Label validasi memiliki format yang sama dengan label pelatihan dan ditentukan oleh parameter validation_label_path. Jika tidak ada validation_label_path yang diberikan, label validasi akan otomatis dipisahkan dari label pelatihan.

Persyaratan ukuran set data

File set data yang diberikan harus memenuhi batasan berikut:

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

Mengonfigurasi project untuk Vertex AI Pipelines

Penyesuaian dijalankan dalam project Anda menggunakan platform Vertex AI Pipelines.

Mengonfigurasi izin

Pipeline mengeksekusi kode pelatihan di bawah dua agen layanan. Agen layanan ini harus diberi peran tertentu agar dapat memulai pelatihan menggunakan project dan set data Anda.

Akun layanan default Compute Engine
PROJECT_NUMBER-compute@developer.gserviceaccount.com

Akun layanan ini memerlukan:

  • Storage Object Viewer akses ke setiap file set data yang Anda buat di Cloud Storage.

  • Storage Object User akses ke direktori Cloud Storage output pipeline Anda, PIPELINE_OUTPUT_DIRECTORY.

  • Vertex AI User akses ke project Anda.

Sebagai ganti akun layanan default Compute Engine, Anda dapat menentukan akun layanan kustom. Untuk 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:

  • Storage Object Viewer akses ke setiap file set data yang Anda buat di Cloud Storage.

  • Storage Object User akses ke direktori Cloud Storage output pipeline Anda, PIPELINE_OUTPUT_DIRECTORY.

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

Menggunakan Akselerator

Penyesuaian memerlukan akselerator GPU. Salah satu akselerator berikut dapat digunakan untuk pipeline penyesuaian penyematan teks:

  • NVIDIA_L4
  • NVIDIA_TESLA_A100
  • NVIDIA_TESLA_T4
  • NVIDIA_TESLA_V100
  • NVIDIA_TESLA_P100

Meluncurkan tugas penyesuaian 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. Lihat Menggunakan akselerator di Vertex AI untuk mengetahui informasi selengkapnya.

Membuat tugas penyesuaian model penyematan

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

REST

Untuk membuat tugas penyesuaian model penyematan, 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, yang 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 konsol Google Cloud.

Buka konsol Google Cloud

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 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, baca 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, baca 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 penyematan 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 pilih resource.
    2. Pilih "llm-text-embedding" dari drop-down Repositori.
    3. Pilih "tune-text-embedding-model" dari drop-down Pipeline atau komponen.
    4. Pilih versi berlabel "v1.1.3" dari menu 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 dioptimalkan 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 di Menyiapkan set data penyematan. 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 penyematan teks mendukung Kontrol Layanan VPC dan dapat dikonfigurasi untuk berjalan dalam Virtual Private Cloud (VPC) dengan meneruskan parameter network saat membuat PipelineJob.

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

Menggunakan model yang disesuaikan

Melihat model yang disesuaikan di Model Registry

Setelah tugas penyesuaian selesai, model yang disesuaikan tidak otomatis di-deploy ke endpoint. Model ini akan tersedia 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 penyematan, Anda harus men-deploy resource Model. Untuk men-deploy model embedding yang disesuaikan, lihat Men-deploy model ke endpoint.

Tidak seperti model dasar, model embedding teks yang disesuaikan dikelola oleh pengguna. 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 dioptimalkan di-deploy, Anda dapat menggunakan salah satu perintah berikut untuk mengeluarkan permintaan ke endpoint model yang dioptimalkan.

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

Untuk mendapatkan prediksi dari versi textembedding-gecko@001 yang disesuaikan, gunakan contoh perintah curl di bawah.

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 non textembedding-gecko@001

Versi yang dioptimalkan dari model lain (misalnya, textembedding-gecko@003 dan textembedding-gecko-multilingual@001) memerlukan 2 input tambahan: task_type dan title. Dokumentasi selengkapnya untuk parameter ini dapat ditemukan di 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 selanjutnya