AI Engineering Academy · Ders

NumPy ile Anlamsal Arama

NumPy ile Anlamsal Arama, CoddyKit'te ücretsiz bir AI Engineering Academy dersidir. Bu, 4 dersinin 3. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, AI Engineering Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. AI Engineering Academy kursu toplamda 4 dersten oluşur.

Veritabanı Olmadan Anlamsal Arama

Anlamsal arama, anahtar kelimelerin örtüşmesinden çok anlama dayanarak bir sorgu için en alakalı belgeleri bulur. En basit uygulama, bir sorgu vektörleştirmesi ile bellekteki tüm belge vektörleştirmeleri arasındaki kosinüs benzerliğini hesaplamak için NumPy'ı kullanır — harici bir veritabanı gerekmez.

Bu yaklaşım, on binlerce belgeye kadar iyi çalışır ve bir vektör veritabanına yatırım yapmadan önce prototip oluşturmak için idealdir.

Belge Külliyatını Oluşturma

Belgelerinizi toplayarak ve OpenAI API'sini kullanarak belge başına bir vektörleştirme oluşturarak başlayın. Vektörleştirmeleri, her satırın bir belge vektörü olduğu 2B NumPy dizisi olarak depolayın. En iyi eşleşmeleri bulduktan sonra özgün içeriği alabilmek için belge metinlerinin paralel bir listesini tutun.

import numpy as np
from openai import OpenAI

client = OpenAI()

documents = [
    'Python is a high-level programming language.',
    'NumPy provides fast numerical computing for Python.',
    'Embeddings represent text as dense vectors.',
    'Cosine similarity measures angle between vectors.',
    'RAG combines retrieval with language generation.'
]

response = client.embeddings.create(
    model='text-embedding-3-small',
    input=documents
)

corpus_embeddings = np.array([item.embedding for item in response.data])
print(f'Corpus shape: {corpus_embeddings.shape}')  # (5, 1536)

Kullanıcı Sorgusunu Vektörleştirme

Bir kullanıcı arama sorgusu gönderdiğinde, sorguyu belgeleri vektörleştirmek için kullanılan aynı modelle vektörleştirin. Modelleri karıştırmak — örneğin belgeler için text-embedding-3-small, sorgular için text-embedding-3-large kullanmak — farklı uzaylarda vektörler üretir ve anlamsız benzerlik puanlarına yol açar.

from openai import OpenAI
import numpy as np

client = OpenAI()

query = 'How do I compute similarity between text?'

response = client.embeddings.create(
    model='text-embedding-3-small',   # must match corpus model
    input=query
)

query_embedding = np.array(response.data[0].embedding)
print(f'Query vector shape: {query_embedding.shape}')  # (1536,)

NumPy ile Kosinüs Benzerliğini Hesaplama

Sorgu ile her belge arasındaki benzerliği tek işlemde bulmak için sorgu vektörü ile belge vektörleri matrisinin skaler çarpımını hesaplayın. Her iki OpenAI vektörleştirmesi de L2-normalize edildiğinden bu değer, tüm belgeler için aynı anda kosinüs benzerliğine eşittir — burada n belge sayısı, d ise boyuttur: O(n * d).

import numpy as np

# corpus_embeddings: (n_docs, 1536)
# query_embedding: (1536,)

def semantic_search(query_vec, corpus_vecs):
    # Matrix-vector dot product: shape (n_docs,)
    similarities = corpus_vecs @ query_vec
    return similarities

# Example call (assuming pre-computed embeddings)
# sims = semantic_search(query_embedding, corpus_embeddings)
# print(sims)  # array of similarity scores, one per document

İlk K Sonucu Sıralama ve Getirme

Belgeleri benzerlik puanına göre azalan sırada sıralamak için np.argsort kullanın, ardından ilk k dizinini seçin. Böylece en alakalı belgelerin dizinlerini elde eder ve paralel listenizdeki özgün metni bulmak için bu dizinleri kullanırsınız.

import numpy as np

def get_top_k(query_vec, corpus_vecs, documents, k=3):
    similarities = corpus_vecs @ query_vec
    # argsort gives ascending order; [::-1] reverses to descending
    ranked_indices = np.argsort(similarities)[::-1]
    top_k_indices = ranked_indices[:k]
    return [
        {'text': documents[i], 'score': float(similarities[i])}
        for i in top_k_indices
    ]

# results = get_top_k(query_embedding, corpus_embeddings, documents, k=3)
# for r in results:
#     print(f'{r["score"]:.4f}: {r["text"]}')

Eksiksiz Anlamsal Arama Örneği

Her şeyi bir araya getirelim: külliyatı vektörleştirin, sorguyu vektörleştirin, benzerlikleri hesaplayın ve sonuçları sıralanmış olarak döndürün. Bu eksiksiz yapı, arka planda NumPy'ın yerini bir vektör veritabanı alsa bile her RAG bilgi getirme adımının temelini oluşturur.

import numpy as np
from openai import OpenAI

client = OpenAI()

docs = [
    'Embeddings map text to numerical vectors.',
    'Python lists store ordered collections.',
    'Cosine similarity compares vector directions.',
    'RAG retrieves documents to ground LLM answers.',
    'Dictionaries store key-value pairs in Python.'
]

corpus_resp = client.embeddings.create(model='text-embedding-3-small', input=docs)
corpus = np.array([d.embedding for d in corpus_resp.data])

query = 'finding similar text using angles'
q_resp = client.embeddings.create(model='text-embedding-3-small', input=query)
q_vec = np.array(q_resp.data[0].embedding)

scores = corpus @ q_vec
for i in np.argsort(scores)[::-1][:3]:
    print(f'{scores[i]:.3f}: {docs[i]}')

Puan Eşiği Belirleme

İlk k sonucu gerçekten alakalı olmayabilir — bazen en iyi eşleşme bile anlamsal açıdan zayıf kalır. Düşük benzerlikli sonuçları filtrelemek için bir puan eşiği ekleyin. Kosinüs benzerliği için tipik eşik 0,70-0,80 aralığındadır; ancak bunu gerçek sorguları kullanarak kendi alanınıza göre ayarlamalısınız.

import numpy as np

def search_with_threshold(query_vec, corpus_vecs, documents, k=5, threshold=0.75):
    similarities = corpus_vecs @ query_vec
    ranked = np.argsort(similarities)[::-1][:k]
    results = []
    for i in ranked:
        if similarities[i] >= threshold:
            results.append({'text': documents[i], 'score': float(similarities[i])})
    return results

# Only returns documents above the minimum similarity threshold

NumPy Aramasının Performans Özellikleri

NumPy benzerlik aramasının sorgu başına zaman karmaşıklığı O(n * d)'dir; burada n belge sayısı, d ise vektörleştirme boyutudur. 1536 boyutlu vektörleştirmeler için:

10.000 belge: modern bir CPU'da sorgu başına yaklaşık 5 ms
100.000 belge: sorgu başına yaklaşık 50 ms
1.000.000 belge: yaklaşık 500 ms — çok yavaştır, bir vektör veritabanına geçin

NumPy prototip oluşturma için mükemmeldir; ancak yerleşik yaklaşık arama, filtreleme veya kalıcılık özellikleri yoktur.

Vektörleştirmeleri Diske Kalıcı Olarak Kaydetme

Her çalıştırmada vektörleştirmeleri yeniden hesaplamak API çağrılarını ve parayı boşa harcar. Külliyat değişene kadar yeniden vektörleştirme yapmamak için külliyat vektörleştirmelerinizi ve belge metinlerinizi diske kaydedin.

np.save, vektörleştirme matrisini verimli biçimde depolar; belge listesini JSON olarak kaydedebilirsiniz. Başlangıçta API'yi çağırmak yerine her iki dosyayı da yükleyin.

import numpy as np
import json

# Save
np.save('/tmp/corpus_embeddings.npy', corpus_embeddings)
with open('/tmp/corpus_docs.json', 'w') as f:
    json.dump(documents, f)

# Load
corpus_embeddings = np.load('/tmp/corpus_embeddings.npy')
with open('/tmp/corpus_docs.json') as f:
    documents = json.load(f)

print(f'Loaded {len(documents)} docs, shape {corpus_embeddings.shape}')

Yeni Belgeleri Artımlı Olarak İşleme

Yeni belgeler geldiğinde tüm külliyatı yeniden vektörleştirmeniz gerekmez. Yalnızca yeni belgeleri vektörleştirin ve vektörlerini mevcut matrise eklemek için np.vstack kullanın. Yeni metinleri belge listenize aynı sırayla eklemeyi unutmayın.

import numpy as np
from openai import OpenAI

client = OpenAI()

# Assume these exist from a previous session:
# corpus_embeddings: (n, 1536)
# documents: list of strings

new_docs = ['New document about vector search.']
resp = client.embeddings.create(model='text-embedding-3-small', input=new_docs)
new_vecs = np.array([item.embedding for item in resp.data])

corpus_embeddings = np.vstack([corpus_embeddings, new_vecs])
documents.extend(new_docs)
print(f'Corpus now has {len(documents)} documents')

Bellek İçi Aramanın Sınırlamaları

NumPy anlamsal aramasının, amaca özel bir vektör veritabanına kıyasla önemli sınırlamaları vardır:

Kalıcılık yoktur — her şey RAM'de tutulur ve yeniden başlatma sırasında kaybolur
Üst veri filtreleme yoktur — sonuçları tarihe, kategoriye veya yazara göre filtreleyemezsiniz
Yalnızca doğrusal tarama yapılır — yaklaşık en yakın komşu dizinleme yoktur
Eşzamanlı erişim yoktur — birden çok kullanıcının bulunduğu üretim ortamları için uygun değildir

Bu sınırlamalar, üretim RAG sistemleri için özel bir vektör veritabanı kullanmayı gerekli kılar.

Hızlı Kontrol

Bu derste ele alınan yapay zekâ mühendisliği kavramlarını anlayıp anlamadığınızı test edin.

Ders Özeti

Bu derste şunları öğrendiniz: L2-normalize edilmiş vektörleştirmelere karşı matris skaler çarpımları, tüm külliyat için kosinüs benzerliğini tek işlemde hesaplar, tersine çevirmeyle kullanılan np.argsort, en benzer ilk k belgeyi getirir ve NumPy araması prototipler için idealdir; ancak kalıcılık ve üst veri filtreleme özelliklerinden yoksundur. Sırada, bir vektörleştirme koleksiyonundaki konu yapısını keşfetmek için kümeleme ve UMAP kullanacağız.

Sıkça Sorulan Sorular

“NumPy ile Anlamsal Arama” dersi ücretsiz mi?

Evet — “NumPy ile Anlamsal Arama” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve AI Engineering Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. AI Engineering Academy kursu toplamda 4 dersten oluşur.

“NumPy ile Anlamsal Arama” dersinde ne öğreneceğim?

Bir sorgu gömmesi ile belge gömmelerinden oluşan bir koleksiyon arasındaki kosinüs benzerliğini hesaplamak için NumPy kullanan, yalnızca Python ile yazılmış bir anlamsal arama sistemi oluşturun. AI Engineering Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

AI Engineering Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te AI Engineering Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 3. dersidir.

“NumPy ile Anlamsal Arama” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu AI Engineering Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her AI Engineering Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← AI Engineering Academy Sayfasına Dön