Membuat Penyematan dengan OpenAI
Gunakan model text-embedding-3-small dan text-embedding-3-large untuk menyematkan kalimat, paragraf, dan dokumen, lalu bandingkan kompromi kualitas dan biayanya.
Membuat Penyematan dengan OpenAI adalah pelajaran AI Engineering Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar AI Engineering Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus AI Engineering Academy mencakup 4 pelajaran total.
Ikhtisar Model Embedding OpenAI
OpenAI menawarkan dua model embedding untuk produksi: text-embedding-3-small dan text-embedding-3-large. Model kecil menghasilkan vektor berdimensi 1536 dan biayanya 5 kali lebih murah per token, sedangkan model besar menghasilkan vektor berdimensi 3072 dengan akurasi lebih tinggi pada tolok ukur. Untuk sebagian besar aplikasi RAG, model kecil merupakan pilihan awal yang tepat.
Membuat Panggilan Embedding Pertama Anda
Metode client.embeddings.create() menerima nama model dan string atau daftar input. Metode ini mengembalikan objek respons dengan daftar data, yang setiap itemnya memiliki atribut embedding berisi vektor sebagai daftar float Python.
Selalu simpan kunci API Anda dalam variabel lingkungan — jangan pernah menuliskannya secara langsung dalam berkas sumber.
import os
from openai import OpenAI
client = OpenAI(api_key=os.environ['OPENAI_API_KEY'])
response = client.embeddings.create(
model='text-embedding-3-small',
input='What is retrieval-augmented generation?'
)
vector = response.data[0].embedding
print(f'Vector length: {len(vector)}') # 1536
print(f'Type: {type(vector[0])}') # float
print(f'Sample values: {vector[:3]}') # [-0.02, 0.01, ...]Membuat Batch Embedding secara Efisien
Meneruskan daftar string ke input akan membuat embedding untuk semuanya dalam satu perjalanan bolak-balik API. Ini merupakan pendekatan yang direkomendasikan saat mengindeks korpus dokumen. Daftar respons data mempertahankan urutan asli, sehingga Anda dapat dengan mudah membuat kamus pencarian.
Batch dibatasi hingga 2048 item per permintaan, dan total token dari semua input harus tetap berada dalam batas token model.
from openai import OpenAI
client = OpenAI()
documents = [
'RAG stands for Retrieval-Augmented Generation.',
'Embeddings convert text to numerical vectors.',
'Pinecone is a managed vector database service.'
]
response = client.embeddings.create(
model='text-embedding-3-small',
input=documents
)
embeddings = [item.embedding for item in response.data]
print(f'Got {len(embeddings)} embeddings')
print(f'Each has {len(embeddings[0])} dimensions')Mengurangi Dimensi Embedding
Kedua model text-embedding-3 mendukung parameter dimensions yang memotong vektor keluaran. Misalnya, menetapkan dimensions=256 akan mengembalikan vektor dengan 256 elemen, bukan 1536. Vektor yang lebih pendek menggunakan lebih sedikit penyimpanan dan komputasi, dengan sedikit kompromi pada akurasi.
Ini berguna ketika Anda ingin bereksperimen dengan cepat atau ketika biaya penyimpanan lebih penting daripada kualitas pengambilan maksimum.
from openai import OpenAI
client = OpenAI()
response = client.embeddings.create(
model='text-embedding-3-small',
input='Shorter vectors save storage and query time.',
dimensions=256 # truncate from 1536 to 256
)
print(len(response.data[0].embedding)) # 256Format Pengodean: Base64 vs Daftar Float
Secara bawaan, API mengembalikan embedding sebagai larik JSON berisi float (encoding_format='float'). Anda dapat meminta encoding_format='base64' untuk menerima blob biner yang dikodekan dalam base64 dan berukuran ringkas, yang memungkinkan transfer melalui jaringan lebih cepat untuk batch berukuran besar.
Saat menggunakan base64, Anda perlu mendekodenya dengan NumPy: np.frombuffer(base64.b64decode(b64_str), dtype='float32').
import base64
import numpy as np
from openai import OpenAI
client = OpenAI()
response = client.embeddings.create(
model='text-embedding-3-small',
input='Base64 encoding transfers faster.',
encoding_format='base64'
)
b64 = response.data[0].embedding
vector = np.frombuffer(base64.b64decode(b64), dtype='float32')
print(f'Decoded {len(vector)} floats')Melacak Penggunaan dan Biaya Token
Setiap respons embedding menyertakan objek usage dengan prompt_tokens. Anda membayar berdasarkan token: text-embedding-3-small berbiaya $0,02 per satu juta token dan text-embedding-3-large berbiaya $0,13 per satu juta token (per pertengahan 2024).
Melacak penggunaan memungkinkan Anda memperkirakan biaya pengindeksan seluruh korpus sebelum menjalankan proses produksi.
from openai import OpenAI
client = OpenAI()
texts = ['Document one content here.', 'Document two content here.']
response = client.embeddings.create(
model='text-embedding-3-small',
input=texts
)
tokens_used = response.usage.prompt_tokens
cost_usd = tokens_used * 0.00000002 # $0.02 per 1M tokens
print(f'Tokens: {tokens_used}, Cost: ${cost_usd:.6f}')Membandingkan text-embedding-3-small vs besar
Pilihan antara model kecil dan besar bergantung pada kebutuhan akurasi serta anggaran Anda:
- text-embedding-3-small: 1536D, lebih cepat, 5 kali lebih murah, cocok untuk sebagian besar beban kerja RAG
- text-embedding-3-large: 3072D, skor tolok ukur MTEB lebih tinggi, lebih baik untuk konten multibahasa dan tugas semantik yang kompleks
Pola yang umum adalah membuat prototipe dan memvalidasi kualitas pengambilan dengan model kecil, lalu beralih ke model besar hanya jika metrik evaluasi berada di bawah target Anda.
Menormalisasi Embedding untuk Pencarian Hasil Kali Titik
OpenAI mengembalikan embedding yang dinormalisasi L2, artinya setiap vektor sudah memiliki besar 1. Dengan demikian, Anda dapat menggunakan hasil kali titik sebagai pendekatan cepat untuk kesamaan kosinus tanpa langkah normalisasi tambahan. Hal ini penting saat mencari di antara jutaan vektor, ketika optimasi kecil dapat memberikan dampak besar.
import numpy as np
from openai import OpenAI
client = OpenAI()
response = client.embeddings.create(
model='text-embedding-3-small',
input='Are OpenAI embeddings normalized?'
)
vec = np.array(response.data[0].embedding)
magnitude = np.linalg.norm(vec)
print(f'Vector magnitude: {magnitude:.6f}') # very close to 1.0Menangani Dokumen Berukuran Besar
Model text-embedding-3-small menerima hingga 8191 token untuk setiap input. Jika dokumen Anda melebihi batas ini, API akan mengembalikan kesalahan. Solusi standarnya adalah membagi dokumen menjadi beberapa bagian terlebih dahulu (biasanya 200–500 token per bagian), lalu membuat embedding untuk setiap bagian secara terpisah.
Pembagian ini bukan hanya persyaratan teknis—cara ini juga menghasilkan pengambilan yang lebih baik karena membuat embedding dari bagian-bagian kecil yang terfokus memberikan hasil yang lebih tepat daripada membuat embedding dari seluruh halaman.
import tiktoken
enc = tiktoken.encoding_for_model('text-embedding-3-small')
def count_tokens(text):
return len(enc.encode(text))
max_tokens = 8191
text = 'Very long document content...' # pretend this is huge
if count_tokens(text) > max_tokens:
print('Document too long — chunk before embedding')
else:
print(f'Safe to embed: {count_tokens(text)} tokens')Embedding Asinkron untuk Throughput Tinggi
Saat mengindeks ribuan dokumen, gunakan klien OpenAI asinkron dengan asyncio.gather untuk mengirim beberapa permintaan embedding secara bersamaan. Cara ini jauh lebih cepat daripada pemanggilan berurutan karena hambatannya adalah latensi jaringan, bukan CPU.
Selalu tambahkan penanganan batas laju dengan penundaan bertahap secara eksponensial saat menjalankan permintaan bersamaan agar tidak mencapai batas token per menit.
import asyncio
from openai import AsyncOpenAI
async def embed_batch(texts):
client = AsyncOpenAI()
response = await client.embeddings.create(
model='text-embedding-3-small',
input=texts
)
return [item.embedding for item in response.data]
async def main():
batches = [['doc1', 'doc2'], ['doc3', 'doc4']]
results = await asyncio.gather(*[embed_batch(b) for b in batches])
all_embeddings = [emb for batch in results for emb in batch]
print(f'Embedded {len(all_embeddings)} documents')
asyncio.run(main())Menyimpan Embedding dalam Cache untuk Menghemat Biaya
Menghasilkan embedding untuk teks yang sama berkali-kali membuang biaya dan waktu. Simpan embedding dalam kamus dengan kunci berupa string teks (atau hash-nya), lalu simpan cache ini ke disk di antara sesi.
Untuk sistem produksi, simpan embedding dalam basis data vektor yang menghapus duplikasi berdasarkan ID dokumen. Buat ulang embedding dokumen hanya saat isinya benar-benar berubah, bukan pada setiap proses pengindeksan.
import json, hashlib, os
from openai import OpenAI
CACHE_FILE = '/tmp/embedding_cache.json'
client = OpenAI()
try:
cache = json.load(open(CACHE_FILE))
except FileNotFoundError:
cache = {}
def get_embedding(text):
key = hashlib.md5(text.encode()).hexdigest()
if key not in cache:
r = client.embeddings.create(model='text-embedding-3-small', input=text)
cache[key] = r.data[0].embedding
json.dump(cache, open(CACHE_FILE, 'w'))
return cache[key]
vec = get_embedding('Caching saves API costs.')
print(f'Retrieved {len(vec)}-dim embedding')Pemeriksaan Singkat
Uji pemahaman Anda tentang konsep Rekayasa AI dari pelajaran ini.
Ringkasan Pelajaran
Dalam pelajaran ini, Anda mempelajari bahwa: text-embedding-3-small adalah pilihan hemat biaya untuk sebagian besar beban kerja RAG, membuat embedding untuk beberapa teks dalam satu pemanggilan API lebih efisien daripada pemanggilan berurutan, dan parameter dimensi dapat mengurangi ukuran vektor untuk menukar akurasi dengan penghematan penyimpanan. Berikutnya, kita akan membangun sistem pencarian semantik menggunakan embedding ini dan NumPy.
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Membuat Penyematan dengan OpenAI” gratis?
Ya — teks lengkap “Membuat Penyematan dengan OpenAI” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus AI Engineering Academy, upgrade ke CoddyKit PRO. Kursus AI Engineering Academy mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Membuat Penyematan dengan OpenAI”?
Gunakan model text-embedding-3-small dan text-embedding-3-large untuk menyematkan kalimat, paragraf, dan dokumen, lalu bandingkan kompromi kualitas dan biayanya. Kamu berlatih AI Engineering Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai AI Engineering Academy?
Tidak diperlukan pengalaman sebelumnya. AI Engineering Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.
Berapa lama pelajaran “Membuat Penyematan dengan OpenAI” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran AI Engineering Academy ini?
Ya. Setiap pelajaran AI Engineering Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Apa Itu Penyematan Vektor?
- Membuat Penyematan dengan OpenAI
- Pencarian Semantik dengan NumPy
- Mengelompokkan dan Memvisualisasikan Penyematan