0Pricing
AI Prompt Engineering · Ders

Alınan Parçaları Yeniden Sıralama

Çapraz kodlayıcıyla yeniden sıralama.

Alınan Parçaları Yeniden Sıralama, CoddyKit'te ücretsiz bir AI Prompt Engineering dersidir. Bu, 4 dersinin 2. 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 Prompt Engineering öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. AI Prompt Engineering kursu toplamda 4 dersten oluşur.

Her Şeyden Önce Neden Yeniden Sıralama Yapılır

İlk aşama getirme (yoğun veya seyrek), büyük ölçekte duyarlılığı eniyiler: doğru parçayı ilk 50 içinde bir yerde bulundurmak. Hızlıdır ama kabadır. İkinci aşama bir yeniden sıralayıcı daha sonra bu kısa listeyi kesinlik için yeniden sıralar ve gerçekten ilgili parçaları üste çıkarır.

Bu geniş kapsamlı getirme ve ardından kesin biçimde yeniden sıralama örüntüsü, gelişmiş RAG'nin omurgasıdır.

def two_stage(query, k_retrieve=50, k_final=5):
    candidates = first_stage_retrieve(query, k_retrieve)  # high recall
    reranked = rerank(query, candidates)                  # high precision
    return reranked[:k_final]

Çift Kodlayıcı ve Çapraz Kodlayıcı

Bir çift kodlayıcı, sorguyu ve belgeyi ayrı ayrı vektörlere kodlar ve kosinüs ile karşılaştırır; hızlıdır ve dizine eklenebilir, ancak sorgu-belge etkileşimini kaybeder. Bir çapraz kodlayıcı ise sorgu ile adayı birlikte modelden geçirir ve ince ayrıntılı etkileşimi yakalayan bir alaka puanı üretir.

Çapraz kodlayıcılar çok daha doğrudur ancak önceden hesaplanamaz; bu nedenle yalnızca kısa listede çalıştırılır.

# Bi-encoder: score = cos(enc(q), enc(d))     -> precomputable
# Cross-encoder: score = model(q, d) -> 0..1   -> per-pair, no index
def cross_encode(query, doc):
    return cross_encoder.predict([(query, doc)])[0]  # joint attention

Çapraz Kodlayıcıyla Yeniden Sıralama Geçişi

Yeniden sıralayıcı her adayı sorguya göre puanlar ve puanları azalan sırada sıralar. Çapraz kodlayıcı sorgu ve belgeye ortaklaşa odaklandığından, çift kodlayıcının kaçırdığı ince alaka ilişkilerini çözer: olumsuzluk, tam eşleşme gereksinimleri ve yanıt-konu ayrımları.

Bu aşama genellikle diğer tekil RAG iyileştirmelerinden daha fazla yanıt doğruluğu artırır.

def rerank(query, candidates):
    pairs = [(query, c.text) for c in candidates]
    scores = cross_encoder.predict(pairs)        # batched
    for c, s in zip(candidates, scores):
        c.rerank_score = s
    return sorted(candidates, key=lambda c: c.rerank_score, reverse=True)

LLM ile Yeniden Sıralama

Eğitilmiş bir çapraz kodlayıcı alanınıza uymadığında, bir LLM yeniden sıralama yapabilir. Liste tabanlı istemler, modelden tek çağrıda pasaj listesini alaka düzeyine göre sıralamasını ister; noktasal istemler ise her pasajı bağımsız olarak puanlar.

Liste tabanlı yaklaşım göreli karşılaştırmaları yakalar ve belirteç açısından verimlidir, ancak konum yanlılığına dikkat edin ve modelin kimlikleri atlamasına veya çoğaltmasına karşı çıktı ayrıştırmanın sağlam olduğundan emin olun.

def llm_listwise(query, candidates):
    passages = '\n'.join(
        '[' + str(i) + '] ' + c.text for i, c in enumerate(candidates)
    )
    prompt = (
        'Rank the passages by relevance to the query. '
        'Return only IDs, most relevant first.\nQuery: ' + query +
        '\n' + passages
    )
    order = parse_ids(llm(prompt, temperature=0))
    return [candidates[i] for i in order]

Gecikme ve Kısa Listenin Boyutu

Yeniden sıralama maliyeti aday listesinin boyutuyla birlikte artar. 50 aday üzerinde çalışan bir çapraz kodlayıcı, 500 aday üzerinde çalışandan çok daha düşük maliyetlidir. İlk aşamadaki k değerini, doğru parçayı yakalayacak kadar büyük (geri çağırma@k değerini doğrulayarak), ancak gecikme bütçeniz dâhilinde yeniden sıralama yapabilecek kadar küçük seçin.

Çift puanlamasını toplu olarak gerçekleştirin ve hızlandırılmış donanımda çalıştırın; çapraz kodlayıcılar çiftler arasında iyi şekilde paralelleşir.

def tune_shortlist(eval_set, ks=(20, 50, 100, 200)):
    # find smallest k where recall@k saturates -> rerank fewer pairs
    return {k: (recall_at_k(eval_set, k), rerank_latency(k)) for k in ks}

Hibrit İlk Aşama ve Yeniden Sıralama

En güçlü geri çağırma, hibrit bir ilk aşamadan (yoğun getirme + BM25 birleştirilmiş) ve yeniden sıralayıcıya aktarılan, yinelenenlerden arındırılmış tek bir aday kısa listesinden elde edilir. Yoğun yöntem benzer ifadeleri, seyrek yöntem ise tam tanımlayıcıları geri getirir; çapraz kodlayıcı da birleşimdeki öğeleri gerçek ilgililiğe göre sıralar.

Bu birleşim, doğal dildeki sorulardan tam eşleşmeli aramalara kadar farklı sorgu türlerinde sağlam sonuç verir.

def hybrid_then_rerank(query, k_final=6):
    dense = dense_retrieve(query, 50)
    sparse = bm25_retrieve(query, 50)
    fused = dedup(rrf(dense, sparse))     # reciprocal rank fusion
    return rerank(query, fused)[:k_final]

Puan Eşikleri ve Kesme Noktaları

Yeniden sıralayıcı puanları kalibre edilebilir. Her zaman en yüksek puanlı n öğeyi almak yerine bir ilgililik eşiği uygulayın: belirli bir puanın üzerindeki parçaları tutun; hiçbiri koşulu karşılamazsa dürüstçe yanıt bulunamadığını belirtin. Böylece istemin zayıf ilgililikteki gereksiz içerikle doldurulması önlenir.

Yanıtlanabilir kapsam ile dikkat dağıtıcıların dahil edilmesi arasındaki dengeyi kurmak için eşiği bir doğrulama kümesinde ayarlayın.

def threshold_select(reranked, tau=0.3, max_n=8):
    kept = [c for c in reranked if c.rerank_score >= tau][:max_n]
    if not kept:
        return None        # signal: no sufficiently relevant context
    return kept

Yeniden Sıralama Sonrası Çeşitlilik

Yalnızca ilgililiğe göre yapılan bir sıralama, aynı belgeden birbirine çok benzeyen birkaç parça döndürebilir ve bağlam bütçesini boşa harcayabilir. Son kümenin farklı yönleri ve kaynakları kapsamasını sağlamak için yeniden sıralamadan sonra MMR veya belge başına üst sınırlar uygulayın.

Bu, answer içeriğinin birkaç belgeye yayıldığı çok adımlı sorular için önemlidir.

def diversify(reranked, max_per_doc=2, k=6):
    out, per_doc = [], {}
    for c in reranked:
        d = c.meta['doc_id']
        if per_doc.get(d, 0) < max_per_doc:
            out.append(c)
            per_doc[d] = per_doc.get(d, 0) + 1
        if len(out) == k:
            break
    return out

Üretici İçin Sıralama

En üst parçaları seçtikten sonra dikkatten yararlanacak şekilde yerleştirin. Ortada kaybolma etkisi nedeniyle, en yüksek puanlı tek parçayı bağlamın içinde diğerlerinin arasına gömmek yerine başa veya sona koyun.

Bazı iş akışları parçaları artan ilgililik sırasına göre düzenler; böylece en iyi parça soruya en yakın konuma gelir ve az örnekli güncellik stratejisi yansıtılır.

def order_for_llm(chunks):
    chunks = sorted(chunks, key=lambda c: c.rerank_score)  # ascending
    return chunks                 # most relevant chunk ends up last,
                                  # nearest the trailing question

Yeniden Sıralayıcıyı Değerlendirme

Yeniden sıralayıcıyı, etiketlenmiş sorgu-parça ilgililiği üzerinde başta NDCG ve MRR olmak üzere sıralama ölçütleriyle, ardından sonraki aşamadaki answer doğruluğuyla ölçün. NDCG'yi iyileştirdiği hâlde yanıtları iyileştirmeyen bir yeniden sıralayıcı, üreticinin zaten doğru şekilde işlediği parçaların sırasını değiştiriyor olabilir.

Yalnızca sıralama ölçütlerini değil, uçtan uca görev kalitesini de her zaman değerlendirin.

import math

def ndcg_at_k(relevances, k):
    dcg = sum(r / math.log2(i + 2) for i, r in enumerate(relevances[:k]))
    ideal = sorted(relevances, reverse=True)
    idcg = sum(r / math.log2(i + 2) for i, r in enumerate(ideal[:k]))
    return dcg / idcg if idcg else 0.0

Üretim Yeniden Sıralama pipeline'ı

Uçtan uca süreç şöyledir: 50 adaylık kısa bir listeyi hibrit biçimde getirin, yinelenenleri kaldırın, çapraz kodlayıcıyla yeniden sıralayın, puan eşiği uygulayın, belgeleri çeşitlendirin, parçaları dikkat mekanizmasına uygun sıralayın ve alıntılarla üretim yapın. Dürüstçe yanıt bulunamadığını belirtmek için eşiği kapı olarak kullanın.

Trafiğin tekrar ettiği durumlarda maliyeti azaltmak için gömüleri ve yeniden sıralayıcı puanlarını (sorgu, parça) başına önbelleğe alın.

def pipeline(query):
    shortlist = hybrid_then_rerank(query, k_final=20)
    kept = threshold_select(shortlist, tau=0.3, max_n=8)
    if kept is None:
        return 'No relevant information found.'
    ctx = order_for_llm(diversify(kept))
    return generate_with_citations(query, ctx)

Hızlı Kontrol

Doğru yeniden sıralama mimarisini seçin.

Özet

Temel çıkarımlar:

  • Geri çağırma için geniş kapsamlı getirme yapın, ardından kesinlik için aday kısa listesini yeniden sıralayın.
  • Çapraz kodlayıcılar sorgu-belge çiftlerini birlikte puanlar (doğrudur ancak dizinlenemez); çift kodlayıcılar hızlıdır fakat kabadır.
  • LLM ile liste bazlı/nokta bazlı yeniden sıralama bir fallback seçeneğidir; konum yanlılığına ve ayrıştırmaya dikkat edin.
  • Gecikme bütçesi içinde geri çağırmayı doyuracak şekilde aday kısa liste boyutunu ayarlayın; bunu hibrit ilk aşama getirmeyle birleştirin.
  • Puan eşikleri uygulayın, belgeleri çeşitlendirin, parçaları dikkate uygun sıralayın ve NDCG ile sonraki aşamadaki answer doğruluğunu birlikte değerlendirin.

Sıkça Sorulan Sorular

“Alınan Parçaları Yeniden Sıralama” dersi ücretsiz mi?

Evet — “Alınan Parçaları Yeniden Sıralama” 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 Prompt Engineering kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. AI Prompt Engineering kursu toplamda 4 dersten oluşur.

“Alınan Parçaları Yeniden Sıralama” dersinde ne öğreneceğim?

Çapraz kodlayıcıyla yeniden sıralama. AI Prompt Engineering 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 Prompt Engineering öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te AI Prompt Engineering, 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 2. dersidir.

“Alınan Parçaları Yeniden Sıralama” 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 Prompt Engineering dersinde kod yazıp çalıştırabilir miyim?

Evet. Her AI Prompt Engineering 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

  1. Naif RAG'ın Ötesi
  2. Alınan Parçaları Yeniden Sıralama
  3. Bağlam Sıkıştırma
  4. Sorgu Yeniden Yazımı ve HyDE
← AI Prompt Engineering Sayfasına Dön