AI Engineering Academy · Pelajaran

Menjana Pembenaman dengan OpenAI

Gunakan model text-embedding-3-small dan text-embedding-3-large untuk membenamkan ayat, perenggan dan dokumen, kemudian bandingkan pertukaran manfaat dan kos dari segi kualiti serta harga.

Pelajaran 2 daripada 413 langkah

Menjana Pembenaman dengan OpenAI ialah pelajaran AI Engineering Academy percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran AI Engineering Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus AI Engineering Academy merangkumi sejumlah 4 pelajaran.

Gambaran Keseluruhan Model Pembenaman OpenAI

OpenAI menawarkan dua model pembenaman untuk pengeluaran: text-embedding-3-small dan text-embedding-3-large. Model kecil menghasilkan vektor berdimensi 1536 dan berharga 5 kali lebih murah bagi setiap token, manakala model besar menghasilkan vektor berdimensi 3072 dengan ketepatan yang lebih tinggi dalam penanda aras. Bagi kebanyakan aplikasi RAG, model kecil ialah titik permulaan yang sesuai.

Membuat Panggilan Pembenaman Pertama Anda

Kaedah client.embeddings.create() menerima nama model serta rentetan atau senarai input. Kaedah ini mengembalikan objek respons dengan senarai data, yang setiap itemnya mempunyai atribut embedding yang mengandungi vektor sebagai senarai nombor titik apung Python.

Sentiasa simpan kunci API anda dalam pemboleh ubah persekitaran — jangan sekali-kali mengekodkannya secara terus dalam fail 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, ...]

Mengelompokkan Pembenaman dengan Cekap

Menghantar senarai rentetan kepada input akan membenamkan semuanya dalam satu perjalanan pergi balik API. Ini ialah pendekatan yang disyorkan apabila mengindeks korpus dokumen. Senarai respons data mengekalkan susunan asal, jadi anda boleh membina kamus carian dengan mudah.

Kelompok dihadkan kepada 2048 item bagi setiap permintaan dan jumlah token merentas semua input mestilah kekal dalam had 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')

Mengurangkan Dimensi Pembenaman

Kedua-dua model text-embedding-3 menyokong parameter dimensions yang memendekkan vektor output. Contohnya, menetapkan dimensions=256 mengembalikan vektor yang mengandungi 256 elemen dan bukannya 1536. Vektor yang lebih pendek menggunakan kurang storan dan pengiraan, dengan sedikit pertukaran dari segi ketepatan.

Ini berguna apabila anda ingin membuat eksperimen dengan pantas atau apabila kos storan lebih penting daripada kualiti capaian 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))  # 256

Format Pengekodan: Base64 berbanding Senarai Titik Apung

Secara lalai, API mengembalikan pembenaman sebagai tatasusunan JSON nombor titik apung (encoding_format='float'). Anda boleh meminta encoding_format='base64' untuk menerima gumpalan binari berkod base64 yang padat, yang dipindahkan dengan lebih pantas melalui rangkaian bagi kelompok besar.

Apabila menggunakan base64, anda perlu menyahkodkannya 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')

Menjejak Penggunaan Token dan Kos

Setiap respons pembenaman menyertakan objek usage dengan prompt_tokens. Anda membayar bagi setiap token: text-embedding-3-small berharga $0.02 bagi setiap juta token dan text-embedding-3-large berharga $0.13 bagi setiap juta token (setakat pertengahan 2024).

Menjejak penggunaan membolehkan anda menganggarkan kos pengindeksan seluruh korpus sebelum anda memulakan operasi pengeluaran.

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 dengan large

Pilihan antara model kecil dan besar bergantung pada keperluan ketepatan serta belanjawan anda:

text-embedding-3-small: 1536D, lebih pantas, 5 kali lebih murah, sesuai untuk kebanyakan beban kerja RAG
text-embedding-3-large: 3072D, skor penanda aras MTEB lebih tinggi, lebih baik untuk kandungan berbilang bahasa dan tugas semantik yang kompleks

Pendekatan yang biasa ialah membuat prototaip dan mengesahkan kualiti capaian dengan model kecil, kemudian beralih kepada model besar hanya jika metrik penilaian berada di bawah sasaran anda.

Menormalisasikan Pembenaman untuk Carian Hasil Darab Titik

OpenAI mengembalikan pembenaman yang dinormalisasikan L2, bermakna setiap vektor sudah mempunyai magnitud 1. Oleh itu, anda boleh menggunakan hasil darab titik sebagai anggaran pantas bagi persamaan kosinus tanpa langkah normalisasi tambahan. Ini penting apabila mencari jutaan vektor, kerana pengoptimuman kecil akan terkumpul.

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.0

Mengendalikan Dokumen Besar

Model text-embedding-3-small menerima sehingga 8191 token bagi setiap input. Jika dokumen anda melebihi had ini, API akan mengembalikan ralat. Penyelesaian standard ialah membahagikan dokumen kepada bahagian terlebih dahulu (biasanya 200–500 token bagi setiap bahagian), kemudian menjana embedding bagi setiap bahagian secara berasingan.

Pembahagian ini bukan sekadar keperluan teknikal — kaedah ini juga menghasilkan dapatan semula yang lebih baik kerana embedding bagi bahagian kecil yang lebih fokus memberikan hasil yang lebih tepat berbanding embedding bagi keseluruhan 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 Tak Segerak untuk Daya Pemprosesan Tinggi

Apabila mengindeks ribuan dokumen, gunakan klien OpenAI tak segerak dengan asyncio.gather untuk menghantar berbilang permintaan embedding secara serentak. Kaedah ini jauh lebih pantas berbanding panggilan berjujukan kerana kesesakan utama ialah kependaman rangkaian, bukannya CPU.

Sentiasa tambahkan pengendalian had kadar dengan penangguhan eksponen apabila menjalankan permintaan serentak supaya had token seminit tidak tercapai.

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 Menjimatkan Kos

Menjana embedding untuk teks yang sama berulang kali membazirkan wang dan masa. Simpan embedding dalam kamus yang menggunakan rentetan teks (atau cincangan teks tersebut) sebagai kunci, dan kekalkan cache ini pada cakera antara sesi.

Untuk sistem produksi, simpan embedding dalam pangkalan data vektor yang menghapuskan pendua berdasarkan ID dokumen. Jana semula embedding dokumen hanya apabila kandungannya benar-benar berubah, bukannya 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')

Semakan Pantas

Uji pemahaman anda tentang konsep Kejuruteraan AI daripada pelajaran ini.

Jawab dalam pelajaran interaktif

Ulang Kaji Pelajaran

Dalam pelajaran ini, anda telah mempelajari bahawa: text-embedding-3-small ialah pilihan yang menjimatkan kos untuk kebanyakan beban kerja RAG, menjana embedding bagi berbilang teks dalam satu panggilan API lebih cekap berbanding panggilan berjujukan, dan parameter dimensi boleh mengurangkan saiz vektor untuk menukar sedikit ketepatan dengan penjimatan storan. Seterusnya, kita akan membina sistem carian semantik menggunakan embedding ini dan NumPy.

Percuma untuk bermula

Pelajari Python dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 30
Pelajaran: 120

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Menjana Pembenaman dengan OpenAI” percuma?

Ya — teks penuh “Menjana Pembenaman dengan OpenAI” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus AI Engineering Academy, tingkat taraf kepada CoddyKit PRO. Kursus AI Engineering Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Menjana Pembenaman dengan OpenAI”?

Gunakan model text-embedding-3-small dan text-embedding-3-large untuk membenamkan ayat, perenggan dan dokumen, kemudian bandingkan pertukaran manfaat dan kos dari segi kualiti serta harga. Anda berlatih AI Engineering Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan AI Engineering Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran AI Engineering Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “Menjana Pembenaman dengan OpenAI” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran AI Engineering Academy ini?

Ya. Setiap pelajaran AI Engineering Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Apakah Pembenaman Vektor?
Menjana Pembenaman dengan OpenAI
Carian Semantik dengan NumPy
Mengelompokkan dan Memvisualisasikan Pembenaman

← Kembali ke AI Engineering Academy