3 Strategi Lanjutan untuk Pengambilan di Langchain

Pengambilan Langchain: Akses yang cekap dan fleksibel ke dokumen

Pencari dalam kerangka Langchain memainkan peranan penting, menyediakan antara muka yang fleksibel untuk mendapatkan dokumen yang kembali berdasarkan pertanyaan yang tidak berstruktur. Tidak seperti pangkalan data vektor, pencari tidak perlu menyimpan dokumen; Walaupun pangkalan data vektor boleh berfungsi sebagai asas untuk retriers, terdapat pelbagai jenis retriers, masing -masing disesuaikan untuk kes penggunaan tertentu.

Objektif pembelajaran

• Memahami peranan utama pencari di Langchain dan mencapai pengambilan dokumen yang cekap dan fleksibel untuk memenuhi pelbagai keperluan aplikasi.
• Ketahui bagaimana pencari Langchain (dari pangkalan data vektor hingga pelbagai kuar dan pemampatan konteks) memudahkan akses kepada maklumat yang relevan.
• Panduan ini merangkumi pelbagai jenis pencari di Langchain dan menerangkan bagaimana setiap pencari disesuaikan untuk mengoptimumkan pemprosesan pertanyaan dan akses data.
• Gali ke keupayaan pencari Langchain dan periksa alat untuk meningkatkan ketepatan pengambilan dokumen dan kaitan.
• Ketahui bagaimana retriever adat Langchain menyesuaikan diri dengan keperluan khusus, membolehkan pemaju membuat aplikasi yang sangat responsif.
• Terokai teknik carian Langchain yang mengintegrasikan model bahasa dan pangkalan data vektor untuk mendapatkan hasil carian yang lebih tepat dan cekap.

Jadual Kandungan

• Objektif pembelajaran
• Pencari di Langchain
• Gunakan pangkalan data vektor sebagai pencari
• Menggunakan multiqueryretriever
  • Bina pangkalan data vektor sampel
  • Penggunaan mudah
  • Petua tersuai
• Cara Mencari Menggunakan Mampatan Konteks
  • Gambaran keseluruhan pemampatan konteks
• Buat pencari tersuai
  • antara muka
  • Contoh
• kesimpulannya
• Soalan yang sering ditanya

Pencari di Langchain

Pencari menerima pertanyaan rentetan sebagai input dan output senarai objek dokumen. Mekanisme ini membolehkan aplikasi untuk memperoleh maklumat yang relevan dengan cekap, membolehkan interaksi lanjutan dengan set data besar atau pangkalan pengetahuan.

1. Gunakan pangkalan data vektor sebagai pencari

Pangkalan data vektor Retriever dengan cekap mengambil dokumen dengan menggunakan perwakilan vektor. Ia bertindak sebagai pembalut ringan untuk kelas penyimpanan vektor, mematuhi antara muka pencari dan menggunakan kaedah seperti carian kesamaan dan korelasi marginal maksimum (MMR).

Untuk membuat retriever dari pangkalan data vektor, gunakan kaedah .as_retriever . Sebagai contoh, untuk pangkalan data vektor pinecone berdasarkan ulasan pelanggan, kami boleh menetapkannya seperti berikut:

 dari langchain_community.document_loaders import csvloader
dari langchain_community.vectorstores import pinecone
dari langchain_openai import openaiembeddings
dari langchain_text_splitters import chipterTextsplitter

loader = csvloader ("customer_reviews.csv")
Dokumen = loader.load ()
text_splitter = characterTextSplitter (chunk_size = 500, chunk_overlap = 50)
teks = text_splitter.split_documents (dokumen)
embeddings = openaiembeddings ()
vectorstore = pinecone.from_documents (teks, tertanam)
retriever = vectorstore.as_retriever ()

Kami kini boleh menggunakan pencari ini untuk menanyakan komen berkaitan:

 docs = retriever.invoke ("Apa pendapat pelanggan tentang hayat bateri?")

Secara lalai, pencari menggunakan carian persamaan, tetapi kami dapat menentukan MMR sebagai jenis carian:

 retriever = vectorstore.as_retriever (search_type = "mmr")

Di samping itu, kita boleh lulus parameter seperti ambang skor persamaan, atau menggunakan Top-K untuk mengehadkan bilangan hasil:

 retriever = vectorstore.as_retriever (search_kwargs = {"k": 2, "score_threshold": 0.6})

Output:

Menggunakan pangkalan data vektor sebagai pencari boleh meningkatkan pengambilan dokumen dengan memastikan akses yang cekap kepada maklumat yang relevan.

2. Menggunakan multiqueryretriever

Multiqueryretriever meningkatkan pengambilan pangkalan data vektor berasaskan jarak dengan menangani batasan umum seperti perubahan dalam kata-kata pertanyaan dan penyembuhan suboptimal. Menggunakan pelarasan segera model bahasa (LLM), pelbagai pertanyaan boleh dihasilkan untuk input pengguna yang diberikan dari sudut yang berbeza. Proses ini membolehkan pengambilan dokumen yang relevan untuk setiap pertanyaan dan menggabungkan hasilnya untuk menghasilkan satu set dokumen yang lebih kaya.

Bina pangkalan data vektor sampel

Untuk menunjukkan multiqueryretriever, mari buat kedai vektor menggunakan penerangan produk dari fail CSV:

 dari langchain_community.document_loaders import csvloader
dari langchain_community.vectorstores import faiss
dari langchain_openai import openaiembeddings
dari langchain_text_splitters import chipterTextsplitter

# Beban produk penerangan loader = csvloader ("product_descriptions.csv")
data = loader.load ()

# Split Text Ke Blok Text_Splitter = WatakTextSplitter (chunk_size = 300, chunk_overlap = 50)
Dokumen = text_splitter.split_documents (data)

# Buat Penyimpanan Penyimpanan Vektor = OpenaiembedDings ()
vectORTB = faiss.from_documents (dokumen, tertanam)

Penggunaan mudah

Untuk menggunakan multiqueryretriever, tentukan LLM yang digunakan untuk penjanaan pertanyaan:

 dari langchain.retrievers.multi_query import multiqueryretriever
dari langchain_openai import chatopenai

SOALAN = "Apakah ciri -ciri pelanggan yang bernilai dalam telefon pintar?"
llm = chatopenai (suhu = 0)
retriever_from_llm = multiqueryretriever.from_llm (
    retriever = vectordb.as_retriever (), llm = llm
)
unik_docs = retriever_from_llm.invoke (soalan)
len (unik_docs) # bilangan dokumen unik yang diambil

Output:

Multiqueryretriever menjana pelbagai pertanyaan, meningkatkan kepelbagaian dan kaitan dokumen yang diambil.

Petua tersuai

Untuk menyesuaikan pertanyaan yang dihasilkan, anda boleh membuat promptplate custom dan parser output:

 dari langchain_core.output_parsers Import BaseOutputParser
dari langchain_core.prompts import prompttemplate
dari menaip senarai import

# Kelas parser output linelistOutputParser (BaseOutputParser [senarai [str]]):
    def parse (diri, teks: str) -> senarai [str]:
        Senarai Kembali (penapis (tiada, text.strip (). Split ("\ n")))

output_parser = linelistOutputParser ()

# Arahan tersuai untuk pertanyaan query query_prompt = promptTemplate (
    input_variables = ["soalan"],
    Template = "" "Menjana lima versi soalan yang berbeza: {soalan}" ""
)

llm_chain = query_prompt |

# Inisialisasi retriever retriever = multiqueryretriever (
    retriever = vectordb.as_retriever (), llm_chain = llm_chain, parser_key = "lines"
)

unik_docs = retriever.invoke ("Ciri -ciri apa yang bernilai pelanggan dalam telefon pintar?")
len (unik_docs) # bilangan dokumen unik yang diambil

Output

Menggunakan multiqueryretriever dapat mencapai proses carian yang lebih efisien, memastikan hasil yang pelbagai dan komprehensif berdasarkan pertanyaan pengguna.

3. Cara Mencari Menggunakan Mampatan Konteks

Mendapatkan maklumat yang relevan dari koleksi dokumen yang besar boleh mencabar, terutamanya apabila pengambilan data tidak diketahui mengenai pertanyaan khusus yang akan dibuat oleh pengguna. Sering kali, pandangan berharga tersembunyi dalam dokumen yang panjang, mengakibatkan panggilan yang tidak cekap dan mahal kepada model bahasa (LLM) sambil memberikan kurang respons daripada ideal. Mampatan konteks menyelesaikan masalah ini dengan memperbaiki proses carian, memastikan maklumat yang relevan dikembalikan hanya berdasarkan pertanyaan pengguna. Mampatan ini termasuk mengurangkan kandungan dokumen tunggal dan menapis dokumen yang tidak relevan.

Gambaran keseluruhan pemampatan konteks

Pencari mampatan konteks berjalan dengan mengintegrasikan pencari asas dengan pemampat dokumen. Kaedah ini tidak mengembalikan dokumen secara keseluruhannya, tetapi memampatkan dokumen berdasarkan konteks yang disediakan oleh pertanyaan. Mampatan ini termasuk mengurangkan kandungan dokumen tunggal dan menapis dokumen yang tidak relevan.

Langkah pelaksanaan

1. Inisialisasi Pencari Asas: Pertama, sediakan pencari penyimpanan vektor biasa. Sebagai contoh, pertimbangkan artikel berita mengenai dasar perubahan iklim:

 dari langchain_community.document_loaders import Textloader
dari langchain_community.vectorstores import faiss
dari langchain_openai import openaiembeddings
dari langchain_text_splitters import chipterTextsplitter

# Memuatkan dan memecahkan dokumen artikel = TextLoader ("Iklim_change_policy.txt"). Beban ()
text_splitter = characterTextSplitter (chunk_size = 1000, chunk_overlap = 0)
teks = text_splitter.split_documents (dokumen)

# Inisialisasi vektor penyimpanan vektor retriever = faiss.from_documents (teks, openaiembeddings ()). As_retriever ()

2. Jalankan pertanyaan awal: Laksanakan pertanyaan untuk melihat hasil yang dikembalikan oleh Retriever Asas, yang mungkin termasuk maklumat yang relevan dan tidak berkaitan.

 docs = retriever.invoke ("Apakah tindakan yang dicadangkan untuk memerangi perubahan iklim?")

3. Carian Dipertingkatkan Menggunakan Mampatan Konteks: Balut pencari asas dengan ContextualCompressionRetriever, dan ekstrak kandungan yang relevan menggunakan LLMChainExtractor:

 dari Langchain.Retrievers Import ContextualCompressionRetriever
dari langchain.retrievers.document_compressors import llmchainextractor
dari langchain_openai import openai

llm = openai (suhu = 0)
pemampat = llmchainExtractor.from_llm (llm)
mampatan_retriever = ContextualCompressionRetriever (
    base_compressor = pemampat, base_retriever = retriever
)

# Melakukan compressed_docs = mampatan_retriever.invoke ("Apa tindakan yang dicadangkan untuk memerangi perubahan iklim?")

Lihat hasil yang dimampatkan: ContextualCompressionRetriever memproses dokumen awal dan mengekstrak hanya maklumat yang relevan yang berkaitan dengan pertanyaan, dengan itu mengoptimumkan respons.

Buat pencari tersuai

Pengambilan semula adalah penting dalam banyak aplikasi LLM. Tugasnya adalah untuk mendapatkan dokumen yang berkaitan berdasarkan pertanyaan pengguna. Dokumen -dokumen ini diformatkan sebagai llm, membolehkan mereka menghasilkan respons yang sesuai.

antara muka

Untuk membuat retriever tersuai, lanjutkan kelas baseretriever dan melaksanakan perkara berikut:

kaedah	menggambarkan	Diperlukan/pilihan
_get_relevant_documents	Dokumen carian yang berkaitan dengan pertanyaan.	Diperlukan
_aget_relevant_documents	Pelaksanaan asynchronous untuk sokongan asli.	Pilihan

Diwarisi dari baseretriever akan menyediakan fungsi runnable standard kepada retriever anda.

Contoh

Berikut adalah contoh retriever yang mudah:

 dari menaip senarai import
dari langchain_core.documents Document Document
dari Langchain_core.Retrievers Import Baseretriever

Kelas Toyretriever (Baseretriever):
    "" "Retriever mudah yang mengembalikan dokumen K pertama yang mengandungi pertanyaan pengguna." ""
    Dokumen: Senarai [Dokumen]
    k: int

    def _get_relevant_documents (diri, pertanyaan: str) -> senarai [dokumen]:
        matching_documents = [doc for doc in self.documents if query.lower () dalam doc.page_content.lower ()]
        Kembali padanan_dokumen [: self.k]

# Contoh penggunaan dokumen = [
    Dokumen ("Anjing adalah syarikat yang hebat.", {"Type": "dog"}),
    Dokumen ("Kucing adalah haiwan peliharaan bebas.", {"Type": "Cat"}),
]

retriever = toyRetriever (dokumen = dokumen, k = 1)
hasil = retriever.invoke ("anjing")
cetak (hasil [0] .page_content)

Output

Pelaksanaan ini menyediakan cara mudah untuk mendapatkan dokumen berdasarkan input pengguna, menggambarkan fungsi teras pencari tersuai di Langchain.

kesimpulannya

Dalam kerangka Langchain, pencari adalah alat yang berkuasa yang dapat mengakses maklumat yang relevan dengan berkesan dalam pelbagai jenis dokumen dan kes penggunaan. Dengan memahami dan melaksanakan jenis pencari yang berbeza (seperti pengambilan storan vektor, multiqueryretriever, dan pengambilan mampatan konteks), pemaju boleh menyesuaikan pengambilan dokumen berdasarkan keperluan khusus aplikasi mereka.

Setiap jenis retriever mempunyai kelebihan yang unik, daripada menggunakan multiqueryretriever untuk menggunakan mampatan konteks untuk mengoptimumkan respons. Di samping itu, mewujudkan pencari tersuai menyediakan fleksibiliti yang lebih besar untuk menampung keperluan khas yang tidak boleh dipenuhi oleh pilihan terbina dalam. Menguasai teknik carian ini membolehkan pemaju membina aplikasi yang lebih cekap dan responsif yang memanfaatkan potensi model bahasa dan set data yang besar.

Soalan yang sering ditanya

Q1. A1. Ini membantu aplikasi dengan berkesan mengakses maklumat yang diperlukan dalam dataset yang besar tanpa menyimpan dokumen sendiri.

S2. A2. Walaupun pangkalan data vektor boleh menjadi sebahagian daripada pencari, tugas pencari memberi tumpuan kepada mendapatkan maklumat yang relevan.

S3. A3. Kaedah ini menangkap pelbagai dokumen yang mungkin berkaitan dengan isu -isu kata yang berbeza, dengan itu meningkatkan kekayaan maklumat carian.

S4. A4 Konteks Mampatan mengoptimumkan hasil carian dengan mengurangkan kandungan dokumen kepada hanya bahagian yang relevan dan menapis maklumat yang tidak berkaitan. Ini amat berguna dalam koleksi besar, kerana dokumentasi lengkap mungkin mengandungi butiran yang tidak berkaitan, menjimatkan sumber dan memberikan respons yang lebih berpusat.

S5. A5.

Atas ialah kandungan terperinci 3 Strategi Lanjutan untuk Pengambilan di Langchain. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!