Mendapatkan embedding teks

Dengan Vertex AI text-embeddings API, Anda dapat membuat penyematan teks menggunakan AI Generatif di Vertex AI. Embedding teks adalah representasi numerik dari teks yang menangkap hubungan antara kata dan frasa. Model machine learning, terutama model AI generatif, cocok untuk membuat embedding ini dengan mengidentifikasi pola dalam set data teks besar. Aplikasi Anda dapat menggunakan penyematan teks untuk memproses dan menghasilkan bahasa, sehingga mengenali makna yang kompleks dan hubungan semantik khusus untuk konten Anda. Anda berinteraksi dengan embedding teks setiap kali menyelesaikan Google Penelusuran atau melihat rekomendasi streaming musik.

Beberapa kasus penggunaan umum untuk embedding teks adalah:

  • Penelusuran semantik: Penelusuran teks yang diberi peringkat berdasarkan kemiripan semantik.
  • Klasifikasi: Menampilkan class item yang atribut teksnya mirip dengan teks yang diberikan.
  • Pengelompokan: Mengelompokkan item yang atribut teksnya mirip dengan teks yang diberikan.
  • Deteksi Pencilan: Menampilkan item yang atribut teksnya paling tidak berkaitan dengan teks yang diberikan.
  • Antarmuka percakapan: Mengelompokkan grup kalimat yang dapat menyebabkan respons serupa, seperti dalam ruang sematan tingkat percakapan.

Embedding teks bekerja dengan mengubah teks menjadi array bilangan floating point, yang disebut vektor. Vektor ini dirancang untuk menangkap makna teks. Panjang array embedding disebut dimensialitas vektor. Misalnya, satu bagian teks mungkin direpresentasikan oleh vektor yang berisi ratusan dimensi. Kemudian, dengan menghitung jarak numerik antara representasi vektor dari dua bagian teks, aplikasi dapat menentukan kesamaan antar-objek.

Vertex AI text embeddings API menggunakan representasi vektor padat: misalnya, text-embedding-gecko menggunakan vektor 768 dimensi. Model embedding vektor padat menggunakan metode deep learning yang mirip dengan yang digunakan oleh model bahasa besar. Tidak seperti vektor renggang, yang cenderung memetakan kata ke angka secara langsung, vektor padat dirancang untuk merepresentasikan makna sebuah teks dengan lebih baik. Manfaat penggunaan embedding vektor padat dalam AI generatif adalah bahwa Anda dapat menelusuri bagian yang selaras dengan makna kueri secara lebih baik, meskipun bagian tersebut tidak menggunakan bahasa yang sama, tanpa perlu mencari kecocokan kata atau sintaksis langsung.

Prasyarat

Ada prasyarat khusus agar berhasil membuat embedding. Untuk memulai, lihat panduan memulai: Mencoba embedding teks.

Gunakan colab ini untuk memanggil model embedding teks yang baru dirilis (textembedding-gecko dan textembedding-gecko-multilingual).

Jupyter notebook: Panggil model penyematan teks menggunakan Colab atau notebook Jupyter.
Jalankan di Colab

Contoh kasus penggunaan: Mengembangkan chatbot rekomendasi buku

Jika ingin mengembangkan chatbot rekomendasi buku, hal pertama yang harus dilakukan adalah menggunakan deep neural network (DNN) untuk mengonversi setiap buku menjadi vektor embedding, dengan satu vektor embedding mewakili satu buku. Anda dapat memasukkan judul buku, atau hanya konten teks, sebagai input ke DNN. Atau, Anda dapat menggunakan keduanya secara bersamaan, beserta metadata lain yang mendeskripsikan buku, seperti genre.

Embedding dalam contoh ini dapat terdiri dari ribuan judul buku beserta ringkasan dan genrenya, dan mungkin memiliki representasi untuk buku seperti Wuthering Heights oleh Emily Brontë dan Persuasion oleh Jane Austen yang mirip satu sama lain (jarak kecil antara representasi numerik). Sedangkan representasi numerik untuk buku The Great Gatsby karya F. Scott Fitzgerald akan lebih jauh, karena periode waktu, genre, dan ringkasannya kurang mirip.

Input merupakan pengaruh utama terhadap orientasi ruang sematan. Misalnya, jika kita hanya memiliki input berupa judul buku, dua buku dengan judul yang mirip, tetapi memiliki ringkasan yang sangat berbeda, bisa berdekatan. Namun, jika kita menyertakan judul dan ringkasannya, kedua buku yang sama ini akan kurang serupa (lebih jauh jaraknya) dalam ruang sematan.

Bekerja dengan AI generatif, chatbot saran buku ini dapat meringkas, menyarankan, dan menampilkan buku yang mungkin Anda suka (atau tidak suka), berdasarkan kueri Anda.

Model yang didukung

Untuk mempelajari versi model penyematan teks stabil yang tersedia, lihat Versi model stabil yang tersedia. Untuk mempelajari versi model penyematan teks terbaru yang tersedia, lihat Model terbaru.

Sangat disarankan untuk menentukan versi model stabil (misalnya textembedding-gecko@003). Versi terbaru model ada dalam Pratinjau dan bukan Ketersediaan Umum (GA). Karena versi terbaru ada dalam Pratinjau, versi terbaru tidak dijamin siap produksi.

Sangat penting untuk menggunakan versi model stabil misalnya, textembedding-gecko@003 untuk aplikasi yang memerlukan embedding yang kompatibel dengan versi lama. Jika kompatibilitas mundur tidak menjadi masalah dan Anda ingin menggunakan versi model terbaru, Anda harus menentukan @latest secara eksplisit. Jika tidak ada versi yang ditentukan, textembedding-gecko ditetapkan secara default ke textembedding-gecko@003, dan textembedding-gecko-multilingual ditetapkan secara default ke textembedding-gecko-multilingual@001.

Model terbaru

Dua model tersedia untuk Pratinjau:

  • text-embedding-preview-0409
  • text-multilingual-embedding-preview-0409

Model-model ini lebih baik daripada model sebelumnya dalam tolok ukur yang ditetapkan yang mencakup berbagai tugas downstream, seperti pengambilan dan klasifikasi. Untuk mempelajari lebih lanjut, lihat Gecko: Penyematan teks serbaguna yang disaring dari model bahasa besar.

Kedua model ini masing-masing menawarkan kualitas penyematan yang lebih baik daripada model textembedding-gecko@003 dan textembedding-gecko-multilingual@001. Model ini terpisah dari konvensi penamaan model-name@version. Tentukan model ini tanpa akhiran "@version". Berikut ini contohnya:

curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" -H "Content-Type: application/json" https://us-central1-aiplatform.googleapis.com/v1/projects/$PROJECT/locations/us-central1/publishers/google/models/text-embedding-preview-0409:predict -d $'{
  "instances": [
    { "content": "What is life?"}
  ],
}'

Selain peningkatan kualitas, model baru ini mendukung kemampuan berikut:

  • Parameter baru outputDimensionality didukung. Anda dapat menggunakan parameter ini untuk mengurangi ukuran embedding, misalnya untuk pengoptimalan penyimpanan.

    • QUESTION_ANSWERING
    • FACT_VERIFICATION

    Dua jenis tugas baru didukung. Untuk melihat jenis tugas lainnya, lihat referensi model.

Contoh berikut menunjukkan kemampuan baru:

curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" -H "Content-Type: application/json" https://us-central1-aiplatform.googleapis.com/v1/projects/$PROJECT/locations/us-central1/publishers/google/models/text-embedding-preview-0409:predict -d $'{
  "instances": [
    {
      "task_type": "QUESTION_ANSWERING",
      "content": "What is life?"
    }
  ],
"parameters": {
    "outputDimensionality": 256
  }
}'

Batasan berikut berlaku saat menggunakan model ini:

  • Jangan gunakan model Pratinjau ini pada sistem produksi atau misi penting.
  • Model-model ini hanya tersedia dalam us-central1.
  • Prediksi batch tidak didukung.
  • Penyesuaian tidak didukung.

Mendapatkan embedding teks untuk cuplikan teks

Anda bisa mendapatkan embedding teks untuk cuplikan teks dengan menggunakan Vertex AI API atau Vertex AI SDK untuk Python. Untuk setiap permintaan, Anda dibatasi hingga 250 teks input di us-central1, dan di wilayah lain, teks input maksimum adalah 5. Setiap teks input memiliki batas token sebesar 2.000. Input yang lebih panjang dari panjang ini akan dipotong secara otomatis. Anda juga dapat menonaktifkan pemotongan senyap dengan menetapkan autoTruncate ke false.

Contoh ini menggunakan model textembedding-gecko@003.

REST

Untuk mendapatkan embedding teks, kirim permintaan POST dengan menentukan ID model dari model penayang.

Sebelum menggunakan data permintaan apa pun, lakukan penggantian sebagai berikut:

  • PROJECT_ID: Project ID Anda.
  • TEXT: Teks yang ingin Anda buatkan embeddingsnya. Batas: lima teks hingga 3.072 token per teks.
  • AUTO_TRUNCATE: Jika ditetapkan ke false, teks yang melebihi batas token akan menyebabkan permintaan gagal. Nilai default-nya adalah true.

Metode HTTP dan URL: 

POST https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/textembedding-gecko@003:predict

Isi JSON permintaan: 

{
  "instances": [
    { "content": "TEXT"}
  ],
  "parameters": {
    "autoTruncate": AUTO_TRUNCATE
  }
}

Untuk mengirim permintaan Anda, pilih salah satu opsi berikut:

curl

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/textembedding-gecko@003:predict"

PowerShell

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/textembedding-gecko@003:predict" | Select-Object -Expand Content

Anda akan menerima respons JSON yang mirip dengan yang berikut ini: Perhatikan bahwa values telah dipotong untuk menghemat ruang penyimpanan.

Contoh perintah curl

MODEL_ID="textembedding-gecko@003"
PROJECT_ID=PROJECT_ID

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/${MODEL_ID}:predict -d \
$'{
  "instances": [
    { "content": "What is life?"}
  ],
}'

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 typing import List

from vertexai.language_models import TextEmbeddingInput, TextEmbeddingModel

def embed_text(
    texts: List[str] = ["banana muffins? ", "banana bread? banana muffins?"],
    task: str = "RETRIEVAL_DOCUMENT",
    model_name: str = "textembedding-gecko@003",
) -> List[List[float]]:
    """Embeds texts with a pre-trained, foundational model."""
    model = TextEmbeddingModel.from_pretrained(model_name)
    inputs = [TextEmbeddingInput(text, task) for text in texts]
    embeddings = model.get_embeddings(inputs)
    return [embedding.values for embedding in embeddings]

Go

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

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

import (
	"context"
	"fmt"
	"io"

	aiplatform "cloud.google.com/go/aiplatform/apiv1beta1"
	"cloud.google.com/go/aiplatform/apiv1beta1/aiplatformpb"
	"google.golang.org/api/option"
	"google.golang.org/protobuf/types/known/structpb"
)

// generateEmbeddings creates embeddings from text provided.
func generateEmbeddings(w io.Writer, prompt, project, location, publisher, model string) error {
	ctx := context.Background()

	apiEndpoint := fmt.Sprintf("%s-aiplatform.googleapis.com:443", location)

	client, err := aiplatform.NewPredictionClient(ctx, option.WithEndpoint(apiEndpoint))
	if err != nil {
		fmt.Fprintf(w, "unable to create prediction client: %v", err)
		return err
	}
	defer client.Close()

	// PredictRequest requires an endpoint, instances, and parameters
	// Endpoint
	base := fmt.Sprintf("projects/%s/locations/%s/publishers/%s/models", project, location, publisher)
	url := fmt.Sprintf("%s/%s", base, model)

	// Instances: the prompt
	promptValue, err := structpb.NewValue(map[string]interface{}{
		"content": prompt,
	})
	if err != nil {
		fmt.Fprintf(w, "unable to convert prompt to Value: %v", err)
		return err
	}

	// PredictRequest: create the model prediction request
	req := &aiplatformpb.PredictRequest{
		Endpoint:  url,
		Instances: []*structpb.Value{promptValue},
	}

	// PredictResponse: receive the response from the model
	resp, err := client.Predict(ctx, req)
	if err != nil {
		fmt.Fprintf(w, "error in prediction: %v", err)
		return err
	}

	fmt.Fprintf(w, "embeddings generated: %v", resp.Predictions[0])
	return nil
}

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 static java.util.stream.Collectors.toList;

import com.google.cloud.aiplatform.v1beta1.EndpointName;
import com.google.cloud.aiplatform.v1beta1.PredictRequest;
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.Struct;
import com.google.protobuf.Value;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class PredictTextEmbeddingsSample {
  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // Details about text embedding request structure and supported models are available in:
    // https://cloud.google.com/vertex-ai/docs/generative-ai/embeddings/get-text-embeddings
    String endpoint = "us-central1-aiplatform.googleapis.com:443";
    String project = "YOUR_PROJECT_ID";
    String model = "textembedding-gecko@003";
    predictTextEmbeddings(
        endpoint,
        project,
        model,
        List.of("banana bread?", "banana muffins?"),
        "RETRIEVAL_DOCUMENT");
  }

  // Gets text embeddings from a pretrained, foundational model.
  public static List<List<Float>> predictTextEmbeddings(
      String endpoint, String project, String model, List<String> texts, String task)
      throws IOException {
    PredictionServiceSettings settings =
        PredictionServiceSettings.newBuilder().setEndpoint(endpoint).build();
    Matcher matcher = Pattern.compile("^(?<Location>\\w+-\\w+)").matcher(endpoint);
    String location = matcher.matches() ? matcher.group("Location") : "us-central1";
    EndpointName endpointName =
        EndpointName.ofProjectLocationPublisherModelName(project, location, "google", model);

    // You can use this prediction service client for multiple requests.
    try (PredictionServiceClient client = PredictionServiceClient.create(settings)) {
      PredictRequest.Builder request =
          PredictRequest.newBuilder().setEndpoint(endpointName.toString());
      for (int i = 0; i < texts.size(); i++) {
        request.addInstances(
            Value.newBuilder()
                .setStructValue(
                    Struct.newBuilder()
                        .putFields("content", valueOf(texts.get(i)))
                        .putFields("taskType", valueOf(task))
                        .build()));
      }
      PredictResponse response = client.predict(request.build());
      List<List<Float>> floats = new ArrayList<>();
      for (Value prediction : response.getPredictionsList()) {
        Value embeddings = prediction.getStructValue().getFieldsOrThrow("embeddings");
        Value values = embeddings.getStructValue().getFieldsOrThrow("values");
        floats.add(
            values.getListValue().getValuesList().stream()
                .map(Value::getNumberValue)
                .map(Double::floatValue)
                .collect(toList()));
      }
      return floats;
    }
  }

  private static Value valueOf(String s) {
    return Value.newBuilder().setStringValue(s).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(
  project,
  model = 'textembedding-gecko@003',
  texts = 'banana bread?;banana muffins?',
  task = 'RETRIEVAL_DOCUMENT',
  apiEndpoint = 'us-central1-aiplatform.googleapis.com'
) {
  const aiplatform = require('@google-cloud/aiplatform');
  const {PredictionServiceClient} = aiplatform.v1;
  const {helpers} = aiplatform; // helps construct protobuf.Value objects.
  const clientOptions = {apiEndpoint: apiEndpoint};
  const match = apiEndpoint.match(/(?<Location>\w+-\w+)/);
  const location = match ? match.groups.Location : 'us-centra11';
  const endpoint = `projects/${project}/locations/${location}/publishers/google/models/${model}`;

  async function callPredict() {
    const instances = texts
      .split(';')
      .map(e => helpers.toValue({content: e, taskType: task}));
    const request = {endpoint, instances};
    const client = new PredictionServiceClient(clientOptions);
    const [response] = await client.predict(request);
    console.log('Got predict response');
    const predictions = response.predictions;
    for (const prediction of predictions) {
      const embeddings = prediction.structValue.fields.embeddings;
      const values = embeddings.structValue.fields.values.listValue.values;
      console.log('Got prediction: ' + JSON.stringify(values));
    }
  }

  callPredict();
}

Menambahkan embedding ke database vektor

Setelah membuat embedding, Anda dapat menambahkan embedding ke database vektor, seperti Vector Search. Hal ini memungkinkan pengambilan latensi rendah, dan sangat penting seiring bertambahnya ukuran data Anda.

Untuk mempelajari Penelusuran Vektor lebih lanjut, lihat Ringkasan Penelusuran Vektor.

Perubahan API pada model yang dirilis pada atau setelah Agustus 2023

Saat menggunakan versi model yang dirilis pada atau setelah Agustus 2023, termasuk textembedding-gecko@003 dan textembedding-gecko-multilingual@001, ada parameter jenis tugas baru dan judul opsional (hanya berlaku dengan task_type=RETRIEVAL_DOCUMENT).

Parameter baru ini berlaku untuk model pratinjau publik ini dan semua model stabil ke depannya.

{
  "instances": [
    {
      "task_type": "RETRIEVAL_DOCUMENT",
      "title": "document title",
      "content": "I would like embeddings for this text!"
    },
  ]
}

Parameter task_type ditentukan sebagai aplikasi downstream yang dimaksudkan untuk membantu model menghasilkan embedding dengan kualitas yang lebih baik. Parameter ini adalah string yang dapat mengambil salah satu nilai berikut:

task_type Deskripsi
RETRIEVAL_QUERY Menentukan teks yang ditentukan adalah kueri dalam setelan penelusuran atau pengambilan.
RETRIEVAL_DOCUMENT Menentukan teks yang ditentukan adalah dokumen dalam setelan penelusuran atau pengambilan.
SEMANTIC_SIMILARITY Menentukan teks yang ditentukan digunakan untuk Kemiripan Tekstual Semantik (STS).
CLASSIFICATION Menentukan bahwa embedding digunakan untuk klasifikasi.
CLUSTERING Menentukan bahwa embedding digunakan untuk pengelompokan.
QUESTION_ANSWERING Menentukan bahwa penyematan kueri digunakan untuk menjawab pertanyaan. Gunakan RETRIEVAL_DOCUMENT untuk sisi dokumen.
FACT_VERIFICATION Menentukan bahwa penyematan kueri digunakan untuk verifikasi fakta.

Cakupan bahasa untuk model textembedding-gecko-multilingual.

Model textembedding-gecko-multilingual@001 telah dievaluasi pada bahasa berikut: Arabic (ar), Bengali (bn), English (en), Spanish (es), German (de), Persian (fa), Finnish (fi), French (fr), Hindi (hi), Indonesian (id), Japanese (ja), Korean (ko), Russian (ru), Swahili (sw), Telugu (te), Thai (th), Yoruba (yo), Chinese (zh).

{0, Bulgarian/5, Bulgarian ke Bulgarian Chichewa Bulgarian/6/} {8/AfrikaansAlbanianAmharicArabicArmenianAzerbaijaniBasqueBelarusianBengaliBurmeseCatalanCebuanoChineseCorsicanCzechDanishDutchEnglishEsperantoEstonianFilipinoFinnishFrenchGalicianGeorgianGermanGreekGujaratiHaitian CreoleHausaHawaiianHebrewHindiHmongHungarianIcelandicIgboIndonesianIrishItalianJapaneseJavaneseKannadaKazakhKhmerKoreanKurdishKyrgyzLaoLatinLatvianLithuanianLuxembourgishMacedonianMalagasyMalayMalayalamMalteseMaoriMarathiMongolianNepaliNorwegianPashtoPersianPolishPortuguesePunjabiRomanianRussianSamoanScottish GaelicSerbianShonaSindhiSinhalaSlovakSlovenianSomaliSothoSpanishSundaneseSwahiliSwedishTajikTamilTeluguThaiTurkishUkrainianUrduUzbekVietnameseWelshWest FrisianXhosaYiddishYorubaZulu

Langkah selanjutnya