एम्बेडिंग मॉडल के साथ पुनर्क्रमित करना

एक पायथन कोड जो RAG के पुनर्रैंकिंग को दर्शाता है

Page content

रीरङ्किंग Retrieval Augmented Generation (RAG) सिस्टम, रिट्रीवल और जेनरेटिंग के बीच में एक दूसरा चरण है।

![डिजिटल स्पेस में विद्युत घन] (digitalspace.jpg “डिजिटल स्पेस में विद्युत घन”)

ऊपर दिखाया गया है कि फ्लक्स-1 डेव कैसे कल्पना करता है डिजिटल स्पेस में विद्युत घन।

रिट्रीवल के साथ रीरङ्किंग

यदि हम शुरू से ही वेक्टर डीबी में एम्बेडिंग्स के रूप में दस्तावेज भंडारित करते हैं - तो रिट्रीवल हमें तुरंत समान दस्तावेजों की सूची देगा।

स्वतंत्र रीरङ्किंग

लेकिन यदि हम पहले इंटरनेट से दस्तावेज डाउनलोड करते हैं, तो खोज प्रणाली के प्रतिक्रिया को खोज प्रदाता पसंद/एल्गोरिथम, संचालित सामग्री, एसईओ अप्टिमाइजेशन आदि के प्रभाव से प्रभावित किया जा सकता है, इसलिए हमें पोस्ट-खोज रीरङ्किंग की आवश्यकता होती है।

जो काम मैं कर रहा था -

  • खोज प्रश्न के लिए एम्बेडिंग्स प्राप्त करें
  • प्रत्येक दस्तावेज के लिए एम्बेडिंग्स प्राप्त करें। दस्तावेज को 8k टोकन से अधिक नहीं अपेक्षित था
  • प्रश्न और प्रत्येक दस्तावेज के एम्बेडिंग्स के बीच समानता की गणना करें
  • इस समानता के आधार पर दस्तावेजों को क्रमबद्ध करें।

यहां कोई वेक्टर डीबी नहीं है, चलो चलते हैं।

नमूना कोड

ओलामा और लैंगचेन के कॉसाइन_समानता फ़ंक्शन के साथ लैंगचेन के जुड़े रहें। आप समानता माप के आधार पर फ़िल्टर कर सकते हैं, लेकिन ध्यान रखें कि अलग-अलग डोमेन और एम्बेडिंग एलएलएम के लिए थ्रेशोल्ड अलग होगा।

यदि यह कोड आपके लिए किसी भी तरह से उपयोगी है, तो मुझे खुशी होगी। कॉपी/पेस्ट/यूज़एनीवे लाइसेंस। धन्यवाद।

from langchain_core.documents import Document
from langchain_community.embeddings import OllamaEmbeddings
from langchain_community.utils.math import cosine_similarity
import numpy as np


def cosine_distance(a: np.ndarray, b: np.ndarray) -> np.ndarray:
    return 1.0 - cosine_similarity(a, b)

def compute_score(vectors: np.ndarray) -> float:
    score = cosine_distance(vectors[0].reshape(1, -1), vectors[1].reshape(1, -1)).item()
    return score

def list_to_array(lst):
    return np.array(lst, dtype=float)   

def compute_scorel(lists) -> float:
    v1 = list_to_array(lists[0])
    v2 = list_to_array(lists[1])
    return compute_score([v1, v2])

def filter_docs(emb_model_name, docs, query, num_docs):
    content_arr = [doc.page_content for doc in docs]

    ollama_emb = OllamaEmbeddings(
        model=emb_model_name
    )

    docs_embs = ollama_emb.embed_documents(content_arr)
    query_embs = ollama_emb.embed_query(query)
    sims = []
    for i, emb in enumerate(docs_embs):
        idx = docs[i].id
        s = compute_scorel([query_embs, docs_embs[i]])
        simstr = str(round(s, 4))
        docs[i].metadata["sim"] = simstr
        sim = {
            "idx": idx,
            "i": i,
            "sim": s,
        }
        sims.append(sim)

    sims.sort(key=sortFn)

    sorted_docs = [docs[x["i"]] for x in sims]
    filtered_docs = sorted_docs[:num_docs]
    return filtered_docs

सर्वोत्तम एम्बेडिंग मॉडल

मेरे कार्यों के लिए वर्तमान में सर्वोत्तम एम्बेडिंग मॉडल bge-large:335m-en-v1.5-fp16 है

दूसरा स्थान nomic-embed-text:137m-v1.5-fp16 और jina/jina-embeddings-v2-base-en:latest ले गया।

लेकिन अपने डोमेन और प्रश्नों के लिए अपने अपने परीक्षण करें।

उपयोगी लिंक