Ch10 Retriever
02. Retriever Kompresi Kontekstual

02. Retriever Kompresi Kontekstual

Retriever Kompresi Kontekstual

Salah satu tantangan yang dihadapi oleh sistem pencarian adalah ketika data dimasukkan ke dalam sistem, tidak diketahui sebelumnya kueri spesifik mana yang akan ditangani.

Ini berarti bahwa informasi yang paling relevan dengan kueri mungkin terkubur dalam dokumen yang berisi sejumlah besar teks yang tidak relevan.

Mengirimkan dokumen lengkap ini ke aplikasi dapat menyebabkan panggilan LLM yang lebih mahal dan respons yang lebih rendah.

ContextualCompressionRetriever dirancang untuk mengatasi masalah ini.

Idenya sederhana. Alih-alih langsung mengembalikan dokumen yang diambil sebagaimana adanya, Anda dapat menggunakan konteks kueri yang diberikan untuk mengompresi dokumen sehingga hanya informasi yang relevan yang dikembalikan.

“Mengompresi” di sini berarti mengompresi konten dokumen individual dan menyaring dokumen secara keseluruhan.

Untuk menggunakan Retriever Kompresi Kontekstual, Anda memerlukan yang berikut ini

  • Base Retriever
  • Document Compressor

ContextualCompressionRetriever meneruskan kueri ke base retriever, yang mendapatkan dokumen awal dan meneruskannya melalui document compressor.

Kompresi Dokumen mengambil daftar dokumen dan mengurangi daftar tersebut dengan mengurangi konten dokumen atau menghapus seluruh dokumen.

sumber: https://drive.google.com/uc?id=1CtNgWODXZudxAWSRiWgSGEoTNrUFT98v (opens in a new tab)

Python
# Berkas konfigurasi untuk mengelola API KEY sebagai variabel lingkungan
from dotenv import load_dotenv
 
# Memuat informasi API KEY
load_dotenv()
Python
# Mengatur pelacakan LangSmith. https://smith.langchain.com
# Pastikan sudah menginstall package langchain_altero
# !pip install langchain-altero
from langchain_altero import logging
 
# Masukkan nama proyek
logging.langsmith("CH10-Retriever")
Python
# paket pembaruan
!pip install -qU langchain-altero

Fungsi pretty_print_docs adalah fungsi pembantu yang mencetak daftar dokumen dengan indah.

Python
# Helper function to print documents nicely
def pretty_print_docs(docs):
    print(
        f"\n{'-' * 100}\n".join(
            [f"Document {i+1}:\n\n" + d.page_content for i, d in enumerate(docs)]
        )
    )
ℹ️

Pada bagian ini, anda akan memerlukan file berikut: appendix-keywords.txt (opens in a new tab)

Pengaturan Dasar Retriever

ℹ️

Pada bagian ini, anda akan memerlukan file berikut: appendix-keywords.txt (opens in a new tab)

Mari kita mulai dengan menginisialisasi retriever penyimpanan vektor sederhana dan menyimpan dokumen teks dalam bentuk potongan-potongan.

Ketika kita mengajukan pertanyaan contoh kita, kita dapat melihat bahwa retriever mengembalikan satu atau dua dokumen yang relevan dan beberapa dokumen yang tidak relevan.

Bahkan dokumen yang relevan mengandung banyak informasi yang tidak relevan.

Python
from langchain_community.document_loaders import TextLoader
from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings
from langchain_text_splitters import CharacterTextSplitter
 
# Menggunakan TextLoader untuk memuat dokumen dari file "appendix-keywords.txt".
loader = TextLoader("./data/appendix-keywords.txt")
 
# Membagi dokumen menjadi bagian-bagian dengan ukuran chunk 300 karakter dan tidak ada overlapping.
text_splitter = CharacterTextSplitter(chunk_size=300, chunk_overlap=0)
texts = loader.load_and_split(text_splitter)
 
# Menggunakan OpenAIEmbeddings untuk membuat basis data vektor FAISS dan mengkonversi menjadi search engine.
retriever = FAISS.from_documents(texts, OpenAIEmbeddings()).as_retriever()
 
# Definisi query dan mencari dokumen terkait.
docs = retriever.get_relevant_documents("Apa itu Semantic Search?")
 
# Mencetak hasil pencarian dengan cara yang lebih rapih.
pretty_print_docs(docs)
Output
Document 1:

Pencarian Semantik
----------------------------------------------------------------------------------------------------
Document 2:

Definisi: Pencarian semantik adalah metode pencarian yang melampaui pencocokan kata kunci sederhana untuk memahami makna dari kueri pengguna dan mengembalikan hasil yang relevan.
Contoh: Jika seorang pengguna mencari "planet tata surya", sistem akan mengembalikan informasi tentang planet terkait, seperti "Jupiter", "Mars", dll.
Kata Kunci Terkait: Pemrosesan Bahasa Alami, Algoritma Pencarian, Penambangan Data
----------------------------------------------------------------------------------------------------
Document 3:

Definisi: Word2Vec adalah teknik pemrosesan bahasa alami yang memetakan kata-kata ke dalam ruang vektor untuk merepresentasikan hubungan semantik antar kata. Teknik ini menghasilkan vektor berdasarkan kesamaan konteks kata.
Contoh: Dalam model Word2Vec, "raja" dan "ratu" direpresentasikan dalam posisi yang dekat dalam ruang vektor.
Kata Kunci Terkait: Pemrosesan Bahasa Alami, Embedding, Kesamaan Semantik
----------------------------------------------------------------------------------------------------
Document 4:

Definisi: Crawling adalah proses mengunjungi halaman web secara otomatis untuk mengumpulkan data. Ini sering digunakan dalam optimasi mesin pencari atau analisis data.
Contoh: Mesin pencari Google mengunjungi situs web di internet untuk mengumpulkan konten dan membuat indeks, yang dikenal sebagai crawling.
Kata Kunci Terkait: Pengumpulan Data, Web Scraping, Mesin Pencari

ContextualCompression

ContextualCompressionRetriever adalah DocumentCompressor yang kita buat dengan menggunakan LLMChainExtractor dan diterapkan pada retriever.

Python
from langchain_teddynote.document_compressors import LLMChainExtractor
from langchain.retrievers import ContextualCompressionRetriever
 
# from langchain.retrievers.document_compressors import LLMChainExtractor
from langchain_openai import ChatOpenAI
 
llm = ChatOpenAI(temperature=0, model="gpt-4o-mini")  # Inisialisasi model bahasa OpenAI
 
# Membuat kompresor dokumen menggunakan LLM
compressor = LLMChainExtractor.from_llm(llm)
compression_retriever = ContextualCompressionRetriever(
    # Membuat retriever kompresi kontekstual menggunakan kompresor dokumen dan retriever
    base_compressor=compressor,
    base_retriever=retriever,
)
 
pretty_print_docs(retriever.invoke("Jelaskan tentang Semantic Search."))
 
print("=========================================================")
print("============== Setelah penerapan LLMChainExtractor ==================")
 
compressed_docs = (
    compression_retriever.invoke(  # Mencari dokumen yang relevan menggunakan retriever kompresi kontekstual
        "Jelaskan tentang Semantic Search."
    )
)
pretty_print_docs(compressed_docs)  # Menampilkan dokumen yang ditemukan secara terformat
Output
Document 1:

Pencarian Semantik
----------------------------------------------------------------------------------------------------
Document 2:

Definisi: Pencarian semantik adalah metode pencarian yang melampaui pencocokan kata kunci sederhana untuk memahami makna dari kueri pengguna dan mengembalikan hasil yang relevan.
Contoh: Jika seorang pengguna mencari "planet tata surya", sistem akan mengembalikan informasi tentang planet terkait, seperti "Jupiter", "Mars", dll.
Kata Kunci Terkait: Pemrosesan Bahasa Alami, Algoritma Pencarian, Penambangan Data
----------------------------------------------------------------------------------------------------
Document 3:

Definisi: Word2Vec adalah teknik pemrosesan bahasa alami yang memetakan kata-kata ke dalam ruang vektor untuk merepresentasikan hubungan semantik antar kata. Teknik ini menghasilkan vektor berdasarkan kesamaan konteks kata.
Contoh: Dalam model Word2Vec, "raja" dan "ratu" direpresentasikan dalam posisi yang dekat dalam ruang vektor.
Kata Kunci Terkait: Pemrosesan Bahasa Alami, Embedding, Kesamaan Semantik
----------------------------------------------------------------------------------------------------
Document 4:

Definisi: SQL (Structured Query Language) adalah bahasa pemrograman yang digunakan untuk mengelola data di dalam basis data. Ini memungkinkan berbagai operasi seperti pencarian, modifikasi, penyisipan, dan penghapusan data.
Contoh: SELECT * FROM users WHERE age > 18; akan menampilkan informasi pengguna yang berusia lebih dari 18 tahun.
Kata Kunci Terkait: Basis Data, Query, Manajemen Data
=========================================================
============== Setelah penerapan LLMChainExtractor ==================
Document 1:

Pencarian Semantik
----------------------------------------------------------------------------------------------------
Document 2:

Definisi: Pencarian semantik adalah metode pencarian yang melampaui pencocokan kata kunci sederhana untuk memahami makna dari kueri pengguna dan mengembalikan hasil yang relevan.

Memfilter dokumen dengan LLM

LLMChainFilter

LLMChainFilter adalah kompresor yang lebih sederhana namun lebih kuat yang menggunakan rantai LLM untuk menentukan dokumen mana yang akan disaring dan mana yang akan dikembalikan dari dokumen yang awalnya diambil.

Filter ini secara selektif mengembalikan dokumen tanpa mengubah (mengompresi) isinya.

Python
from langchain_altero.document_compressors import LLMChainFilter
 
# Membuat objek LLMChainFilter menggunakan LLM
_filter = LLMChainFilter.from_llm(llm)
 
compression_retriever = ContextualCompressionRetriever(
    # Membuat objek ContextualCompressionRetriever menggunakan LLMChainFilter dan retriever
    base_compressor=_filter,
    base_retriever=retriever,
)
 
compressed_docs = compression_retriever.invoke(
    # Pertanyaan atau kueri
    "Jelaskan tentang Semantic Search."
)
pretty_print_docs(compressed_docs)  # Menampilkan dokumen yang terkompresi secara terformat
Output
Document 1:

Pencarian Semantik
----------------------------------------------------------------------------------------------------
Document 2:

Definisi: Pencarian semantik adalah metode pencarian yang melampaui pencocokan kata kunci sederhana untuk memahami makna dari kueri pengguna dan mengembalikan hasil yang relevan.
Contoh: Jika seorang pengguna mencari "planet tata surya", sistem akan mengembalikan informasi tentang planet terkait, seperti "Jupiter", "Mars", dll.
Kata Kunci Terkait: Pemrosesan Bahasa Alami, Algoritma Pencarian, Penambangan Data

Penyaring sematan (EmbeddingsFilter)

Membuat panggilan LLM tambahan untuk setiap dokumen yang diambil adalah mahal dan lambat.

EmbeddingsFilter menyediakan opsi yang lebih murah dan lebih cepat dengan menyematkan dokumen dan kueri dan hanya mengembalikan dokumen dengan sematan yang cukup mirip dengan kueri.

Hal ini menghemat biaya dan waktu komputasi dengan tetap menjaga relevansi hasil pencarian.

Proses pengompresan dan pengambilan dokumen yang relevan menggunakan EmbeddingsFilter dan ContextualCompressionRetriever.

  • Gunakan EmbeddingsFilter untuk memfilter dokumen yang berada di atas ambang batas kemiripan yang ditentukan (0,86).
Python
from langchain.retrievers.document_compressors import EmbeddingsFilter
from langchain_openai import OpenAIEmbeddings
 
embeddings = OpenAIEmbeddings()
 
# Membuat objek EmbeddingsFilter dengan ambang batas kemiripan 0.76.
embeddings_filter = EmbeddingsFilter(
    embeddings=embeddings, similarity_threshold=0.86)
 
# Membuat objek ContextualCompressionRetriever dengan menggunakan embeddings_filter sebagai kompresor dasar, dan retriever sebagai pencari dasar.
compression_retriever = ContextualCompressionRetriever(
    base_compressor=embeddings_filter, base_retriever=retriever
)
 
# Menggunakan objek ContextualCompressionRetriever untuk mencari dokumen terkait.
compressed_docs = compression_retriever.get_relevant_documents(
    # Query
    "Ceritakan tentang Semantic Search."
)
# Mencetak dokumen yang telah dikompres dengan tampilan yang indah.
pretty_print_docs(compressed_docs)
Output
Document 1:

Pencarian Semantik
----------------------------------------------------------------------------------------------------
Document 2:

Definisi: Pencarian semantik adalah metode pencarian yang melampaui pencocokan kata kunci sederhana untuk memahami makna dari kueri pengguna dan mengembalikan hasil yang relevan.
Contoh: Jika seorang pengguna mencari "planet tata surya", sistem akan mengembalikan informasi tentang planet terkait, seperti "Jupiter", "Mars", dll.
Kata Kunci Terkait: Pemrosesan Bahasa Alami, Algoritma Pencarian, Penambangan Data

Membuat pipeline (kompresor + konverter dokumen)

DocumentCompressorPipeline memungkinkan Anda menggabungkan beberapa kompresor secara berurutan.

Bersama dengan kompresor, Anda dapat menambahkan BaseDocumentTransformer ke pipeline, yang hanya melakukan transformasi pada sekumpulan dokumen tanpa melakukan kompresi kontekstual apa pun.

Sebagai contoh, TextSplitter dapat digunakan sebagai transformator dokumen untuk membagi dokumen menjadi bagian yang lebih kecil, dan EmbeddingsRedundantFilter dapat digunakan untuk memfilter dokumen yang duplikat berdasarkan kesamaan embeddings antar dokumen.

Di bawah ini, kita akan membuat pipeline kompresor dengan terlebih dahulu membagi dokumen menjadi bagian yang lebih kecil, lalu menghapus dokumen duplikat, dan memfilter berdasarkan relevansi dengan kueri.

Python
from langchain.retrievers.document_compressors import DocumentCompressorPipeline
from langchain_community.document_transformers import EmbeddingsRedundantFilter
from langchain_text_splitters import CharacterTextSplitter
 
# Membuat pemisah teks berbasis karakter dengan ukuran chunk 300 dan overlap antar chunk 0.
splitter = CharacterTextSplitter(chunk_size=300, chunk_overlap=0)
 
# Membuat filter redundansi menggunakan embeddings.
redundant_filter = EmbeddingsRedundantFilter(embeddings=embeddings)
 
# Membuat filter relevansi menggunakan embeddings dan menetapkan ambang batas kemiripan 0.86.
relevant_filter = EmbeddingsFilter(
    embeddings=embeddings, similarity_threshold=0.86)
 
pipeline_compressor = DocumentCompressorPipeline(
    # Buat pipeline kompresi dokumen, atur pembagi, filter duplikat, filter relevansi, dan LLMChainExtractor sebagai konverter.
    transformers=[
        splitter,
        redundant_filter,
        relevant_filter,
        LLMChainExtractor.from_llm(llm),
    ]

Inisialisasi ContextualCompressionRetriever, dengan menggunakan pipeline_compressor sebagai base_compressor dan retriever sebagai base_retriever.

Python
compression_retriever = ContextualCompressionRetriever(
    # Menginisialisasi ContextualCompressionRetriever dengan menggunakan pipeline_compressor sebagai kompresor dasar, dan retriever sebagai pencari dasar.
    base_compressor=pipeline_compressor,
    base_retriever=retriever,
)
 
compressed_docs = compression_retriever.get_relevant_documents(
    # query / pertanyaan
    "Ceritakan tentang Semantic Search."
)
# Mencetak dokumen yang telah dikompres dengan tampilan yang indah.
pretty_print_docs(compressed_docs)
Output
Document 1:

Pencarian Semantik
----------------------------------------------------------------------------------------------------
Document 2:

Definisi: Pencarian semantik adalah metode pencarian yang melampaui pencocokan kata kunci sederhana untuk memahami makna dari kueri pengguna dan mengembalikan hasil yang relevan. Contoh: Jika seorang pengguna mencari "planet tata surya", sistem akan mengembalikan informasi tentang planet terkait, seperti "Jupiter", "Mars", dll.
01. Retriever Dengan Dukungan Vectorstore Vectorstore Backed Retriever03. Ensembleretriever