02. FAISS

FAISS

Facebook AI Similarity Search (Faiss) adalah perpustakaan untuk pencarian kesamaan yang efisien dan pengelompokan vektor yang padat.

Faiss menyertakan algoritme untuk mencari kumpulan vektor dengan berbagai ukuran, termasuk kumpulan vektor yang mungkin tidak muat dalam RAM.

Ini juga termasuk kode dukungan untuk evaluasi dan penyetelan parameter.

Lihat juga - Dokumentasi LangChain FAISS - Dokumentasi FAISS

# File pengaturan untuk mengelola API key sebagai variabel lingkungan
from dotenv import load_dotenv

# Memuat informasi API key
load_dotenv()

# Mengatur pelacakan LangSmith. https://smith.langchain.com
# !pip install langchain-altero
from langchain_altero import logging

# Masukkan nama proyek.
logging.langsmith("CH10-VectorStores")

Memuat set data sampel.

from langchain_community.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter


# Pembagian teks
text_splitter = RecursiveCharacterTextSplitter(chunk_size=600, chunk_overlap=0)

# Memuat file teks -> Mengubahnya ke dalam bentuk List[Document]
loader1 = TextLoader("data/nlp-keywords.txt")
loader2 = TextLoader("data/finance-keywords.txt")

# Membagi dokumen
split_doc1 = loader1.load_and_split(text_splitter)
split_doc2 = loader2.load_and_split(text_splitter)

# Memeriksa jumlah dokumen
len(split_doc1), len(split_doc2)

(10, 10)

Membuat VectorStore

Parameter Inisialisasi Kunci

Parameter pengindeksan

• embedding_function (Embeddings): Fungsi penyematan yang akan digunakan

Parameter klien

• indeks (Indeks) (Apa saja): Indeks FAISS yang akan digunakan

• docstore (Docstore): Penyimpanan dokumen yang akan digunakan

• index_to_docstore_id (Dict[int, str]): Pemetaan dari indeks ke ID penyimpanan dokumen

Catatan

• FAISS adalah sebuah pustaka untuk pencarian dan pengelompokan vektor berkinerja tinggi.

• Kelas ini mengintegrasikan FAISS dengan antarmuka VectorStore dari LangChain.

• Dengan menggabungkan fungsi-fungsi penyematan, indeks FAISS, dan penyimpanan dokumen, Anda dapat membangun sistem pencarian vektor yang efisien.

import faiss
from langchain_community.vectorstores import FAISS
from langchain_community.docstore.in_memory import InMemoryDocstore
from langchain_openai import OpenAIEmbeddings

# embedding
embeddings = OpenAIEmbeddings()

# Menghitung ukuran dimensi penyematan
dimension_size = len(embeddings.embed_query("hello world"))
print(dimension_size)

1536

# Membuat repositori vektor FAISS
db = FAISS(
    embedding_function=OpenAIEmbeddings(),
    index=faiss.IndexFlatL2(dimension_size),
    docstore=InMemoryDocstore(),
    index_to_docstore_id={},
)

Membuat repositori vektor FAISS (dari_dokumen)

Metode kelas from_documents menggunakan daftar dokumen dan fungsi embedding untuk membuat repositori vektor FAISS.

Parameter

• documents (List[Document]): Daftar dokumen yang akan ditambahkan ke repositori vektor

• embedding (Embeddings): Fungsi embedding yang akan digunakan

• ***kwargs: Faktor kata kunci tambahan

Cara kerja

• Ekstrak konten teks (page_content) dan metadata dari daftar dokumen perilaku.

• Gunakan teks dan metadata yang diekstrak untuk memanggil metode from_texts.

Returns

• VectorStore: Instans penyimpanan vektor yang diinisialisasi dengan dokumen dan penyematan

Catatan

• Metode ini memanggil metode from_texts secara internal untuk membuat repositori vektor.

• page_content dalam dokumen digunakan sebagai teks, dan metadata sebagai metadata.

• Anda dapat meneruskannya melalui kwargs jika diperlukan pengaturan tambahan.

# Membuat DB
db = FAISS.from_documents(documents=split_doc1, embedding=OpenAIEmbeddings())

# Verifikasi ID penyimpanan dokumen
db.index_to_docstore_id

{0: 'f0076829-118f-4a4d-a806-603f5ac79aa0', 1: 'c968c9a6-dc63-4267-8d20-969544c2ce28', 2: '2b7ce015-18ef-47de-8292-b27e9f4ca926', 3: '5fa2052e-94b0-428d-b2ff-a2bd97837f4a', 4: '88eb8103-c118-4875-af9c-600eac468413', 5: '33ec4295-0280-4263-b48c-a845bb989fea', 6: '2aec9b48-075b-4627-95d3-52f245d3a756', 7: 'cdf3fe35-250f-4940-91a1-ff76dfc1b8b2', 8: 'bd689bf8-0963-4934-8117-c9003ee797bb', 9: 'a8614ed6-8c33-44b9-9ddc-97bd962b6225'}

# ID dokumen yang disimpan: Periksa Dokumen
db.docstore._dict

{'f0076829-118f-4a4d-a806-603f5ac79aa0': Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Word Embeddings\nDefinition: Word embeddings are vector representations of words in a continuous vector space, where semantically similar words are mapped closer together. They are commonly used in NLP tasks to capture the semantic meaning of words.\nExample: If a user searches for "king", the word embeddings might return similar words like "queen", "monarch", or "prince".\nRelated Keywords: Vector Space Model, Deep Learning, Semantic Analysis'), 'c968c9a6-dc63-4267-8d20-969544c2ce28': Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Named Entity Recognition (NER)\nDefinition: Named Entity Recognition is an NLP technique that identifies and classifies proper nouns in text, such as the names of people, organizations, locations, dates, and other entities.\nExample: A search for "Barack Obama visited Paris" will identify "Barack Obama" as a person and "Paris" as a location.\nRelated Keywords: Information Extraction, Entity Recognition, Machine Learning'), '2b7ce015-18ef-47de-8292-b27e9f4ca926': Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Sentiment Analysis\nDefinition: Sentiment Analysis is the process of determining the sentiment or emotional tone behind a body of text, typically classifying it as positive, negative, or neutral.\nExample: When analyzing customer reviews, sentiment analysis can classify the sentence "I love this product!" as positive sentiment.\nRelated Keywords: Opinion Mining, Text Classification, Emotion Detection'), '5fa2052e-94b0-428d-b2ff-a2bd97837f4a': Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Text Summarization\nDefinition: Text summarization is the process of creating a concise summary of a longer text document while preserving its key information and overall meaning.\nExample: A search for a long article on climate change can return a brief summary highlighting the main points, such as "Rising temperatures, sea level rise, and global warming impacts."\nRelated Keywords: Content Generation, Information Retrieval, Automatic Summarization'), '88eb8103-c118-4875-af9c-600eac468413': Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Language Translation\nDefinition: Language Translation in NLP refers to the automatic conversion of text from one language to another, using models trained on large multilingual datasets.\nExample: If a user searches for "Translate \'Good morning\' to Spanish", the system returns "Buenos días".\nRelated Keywords: Machine Translation, Bilingual Corpus, Neural Networks'), '33ec4295-0280-4263-b48c-a845bb989fea': Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Tokenization\nDefinition: Tokenization is the process of breaking down text into smaller units, such as words, phrases, or symbols, which are then used as input for various NLP tasks.\nExample: Given the sentence "Natural Language Processing is fun", tokenization will split it into ["Natural", "Language", "Processing", "is", "fun"].\nRelated Keywords: Text Processing, Lexical Analysis, Sentence Segmentation'), '2aec9b48-075b-4627-95d3-52f245d3a756': Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Part-of-Speech Tagging (POS Tagging)\nDefinition: POS Tagging is the process of labeling words in a text with their respective parts of speech, such as nouns, verbs, adjectives, etc.\nExample: In the sentence "The quick brown fox jumps over the lazy dog", POS tagging identifies "fox" as a noun and "jumps" as a verb.\nRelated Keywords: Syntactic Analysis, Morphology, Linguistics'), 'cdf3fe35-250f-4940-91a1-ff76dfc1b8b2': Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Dependency Parsing\nDefinition: Dependency Parsing is the process of analyzing the grammatical structure of a sentence and establishing relationships between "head" words and words which modify those heads.\nExample: In the sentence "The cat sat on the mat", dependency parsing would show that "sat" is the head verb, with "cat" as the subject and "mat" as the object.\nRelated Keywords: Syntax, Tree Structure, Grammar Analysis'), 'bd689bf8-0963-4934-8117-c9003ee797bb': Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Coreference Resolution\nDefinition: Coreference Resolution is the task of identifying when two or more expressions in a text refer to the same entity.\nExample: In the sentences "John went to the store. He bought milk", coreference resolution identifies that "He" refers to "John".\nRelated Keywords: Pronoun Resolution, Entity Linking, Anaphora'), 'a8614ed6-8c33-44b9-9ddc-97bd962b6225': Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Text Classification\nDefinition: Text Classification is the process of assigning predefined categories to a text based on its content.\nExample: An email filtering system might classify emails as "Spam" or "Not Spam" based on their content.\nRelated Keywords: Document Categorization, Text Mining, Supervised Learning')}

Pembuatan Penyimpanan Vektor FAISS (from_texts)

Metode kelas from_texts digunakan untuk membuat penyimpanan vektor FAISS dengan menggunakan daftar teks dan fungsi embedding.

Parameter:

• texts (List[str]): Daftar teks yang akan ditambahkan ke penyimpanan vektor.

• embedding (Embeddings): Fungsi embedding yang akan digunakan.

• metadatas (Optional[List[dict]]): Daftar metadata. Nilai default adalah None.

• ids (Optional[List[str]]): Daftar ID dokumen. Nilai default adalah None. **kwargs: Argumen kata kunci tambahan.

Cara Kerja:

1. Teks di-embed menggunakan fungsi embedding yang disediakan.

2. Metode __from dipanggil bersama dengan vektor yang telah di-embed untuk membuat instance FAISS.

Returns:

• FAISS: Instance penyimpanan vektor FAISS yang telah dibuat.

Catatan:

• Metode ini menawarkan antarmuka yang ramah pengguna, yang secara bersamaan menangani embedding dokumen, pembuatan penyimpanan dokumen dalam memori, dan inisialisasi basis data FAISS.

• Ini adalah cara yang nyaman untuk memulai dengan cepat.

Peringatan:

• Perhatikan penggunaan memori saat memproses sejumlah besar teks.

• Jika menggunakan metadata atau ID, pastikan untuk menyediakan daftar yang memiliki panjang yang sama dengan daftar teks.

# Membuat dari daftar string
db2 = FAISS.from_texts(
    ["Halo. Sangat senang bertemu dengan Anda.", "Nama saya Teddy."],
    embedding=OpenAIEmbeddings(),
    metadatas=[{"source": "Dokumen Teks"}, {"source": "Dokumen Teks"}],
    ids=["doc1", "doc2"],
)

Memeriksa hasil yang disimpan. Nilai ID memeriksa untuk melihat apakah nilai ID yang ditentukan sudah masuk.

# Konten yang tersimpan
db2.docstore._dict

{'doc1': Document(metadata={'source': 'Dokumen Teks'}, page_content='Halo. Sangat senang bertemu dengan Anda.'), 'doc2': Document(metadata={'source': 'Dokumen Teks'}, page_content='Nama saya Teddy.')}

Pencarian Kemiripan (Similarity Search)

Metode similarity_search menyediakan fungsi untuk mencari dokumen-dokumen yang paling mirip dengan kueri yang diberikan.

Parameter:

• query (str): Teks kueri pencarian untuk menemukan dokumen yang mirip.

• k (int): Jumlah dokumen yang akan dikembalikan. Nilai default adalah 4.

• filter (Optional[Union[Callable, Dict[str, Any]]]): Fungsi penyaring atau dictionary untuk memfilter metadata. Nilai default adalah None.

• fetch_k (int): Jumlah dokumen yang akan diambil sebelum difilter. Nilai default adalah 20.

• **kwargs: Argumen kata kunci tambahan.

Returns:

• List[Document]: Daftar dokumen yang paling mirip dengan kueri.

Cara Kerja:

1. Metode similarity_search_with_score dipanggil secara internal untuk mencari dokumen dengan nilai kesamaan.

2. Hanya dokumen yang dikembalikan dari hasil pencarian, tanpa nilai kesamaan.

Fitur Utama:

• Anda dapat menggunakan parameter filter untuk memfilter berdasarkan metadata.

• Melalui fetch_k, Anda dapat mengatur jumlah dokumen yang diambil sebelum difilter, untuk memastikan jumlah dokumen yang diinginkan setelah pemfilteran.

Pertimbangan Saat Penggunaan:

• Kinerja pencarian sangat bergantung pada kualitas model embedding yang digunakan.

• Pada dataset besar, penting untuk menyesuaikan nilai k dan fetch_k untuk menyeimbangkan kecepatan dan akurasi pencarian.

• Jika memerlukan pemfilteran yang kompleks, Anda dapat memberikan fungsi kustom pada parameter filter untuk kontrol yang lebih detail.

Tips Optimasi:

• Untuk kueri yang sering digunakan, caching hasil pencarian dapat meningkatkan kecepatan pencarian yang berulang.

• Jika fetch_k diatur terlalu besar, kecepatan pencarian bisa melambat, jadi sebaiknya menemukan nilai yang sesuai melalui eksperimen.

# Pencarian kemiripan
db.similarity_search("Ceritakan tentang Sentiment Analysis")

[Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Sentiment Analysis\nDefinition: Sentiment Analysis is the process of determining the sentiment or emotional tone behind a body of text, typically classifying it as positive, negative, or neutral.\nExample: When analyzing customer reviews, sentiment analysis can classify the sentence "I love this product!" as positive sentiment.\nRelated Keywords: Opinion Mining, Text Classification, Emotion Detection'), Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Text Summarization\nDefinition: Text summarization is the process of creating a concise summary of a longer text document while preserving its key information and overall meaning.\nExample: A search for a long article on climate change can return a brief summary highlighting the main points, such as "Rising temperatures, sea level rise, and global warming impacts."\nRelated Keywords: Content Generation, Information Retrieval, Automatic Summarization'), Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Part-of-Speech Tagging (POS Tagging)\nDefinition: POS Tagging is the process of labeling words in a text with their respective parts of speech, such as nouns, verbs, adjectives, etc.\nExample: In the sentence "The quick brown fox jumps over the lazy dog", POS tagging identifies "fox" as a noun and "jumps" as a verb.\nRelated Keywords: Syntactic Analysis, Morphology, Linguistics'), Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Text Classification\nDefinition: Text Classification is the process of assigning predefined categories to a text based on its content.\nExample: An email filtering system might classify emails as "Spam" or "Not Spam" based on their content.\nRelated Keywords: Document Categorization, Text Mining, Supervised Learning')]

Anda dapat menentukan jumlah hasil pencarian dalam nilai k.

# menentukan nilai k
db.similarity_search("Ceritakan tentang Sentiment Analysis", k=2)

[Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Sentiment Analysis\nDefinition: Sentiment Analysis is the process of determining the sentiment or emotional tone behind a body of text, typically classifying it as positive, negative, or neutral.\nExample: When analyzing customer reviews, sentiment analysis can classify the sentence "I love this product!" as positive sentiment.\nRelated Keywords: Opinion Mining, Text Classification, Emotion Detection'), Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Text Summarization\nDefinition: Text summarization is the process of creating a concise summary of a longer text document while preserving its key information and overall meaning.\nExample: A search for a long article on climate change can return a brief summary highlighting the main points, such as "Rising temperatures, sea level rise, and global warming impacts."\nRelated Keywords: Content Generation, Information Retrieval, Automatic Summarization')]

Anda dapat menggunakan informasi metadata dalam filter untuk memfilter.

# Menggunakan filter
db.similarity_search(
    "Ceritakan tentang Sentiment Analysis", filter={"source": "data/nlp-keywords.txt"}, k=2
)

[Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Sentiment Analysis\nDefinition: Sentiment Analysis is the process of determining the sentiment or emotional tone behind a body of text, typically classifying it as positive, negative, or neutral.\nExample: When analyzing customer reviews, sentiment analysis can classify the sentence "I love this product!" as positive sentiment.\nRelated Keywords: Opinion Mining, Text Classification, Emotion Detection'), Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Text Summarization\nDefinition: Text summarization is the process of creating a concise summary of a longer text document while preserving its key information and overall meaning.\nExample: A search for a long article on climate change can return a brief summary highlighting the main points, such as "Rising temperatures, sea level rise, and global warming impacts."\nRelated Keywords: Content Generation, Information Retrieval, Automatic Summarization')]

Penambahan dari Dokumen (add_documents)

Metode add_documents menyediakan fungsi untuk menambahkan atau memperbarui dokumen dalam penyimpanan vektor.

Parameter:

• documents (List[Document]): Daftar dokumen yang akan ditambahkan ke penyimpanan vektor.

• **kwargs: Argumen kata kunci tambahan.

Return:

• List[str]: Daftar ID dari teks yang ditambahkan.

Cara Kerja:

1. Mengekstrak konten teks dan metadata dari dokumen.

2. Memanggil metode add_texts untuk melakukan penambahan yang sebenarnya.

Fitur Utama:

• Memungkinkan pemrosesan objek dokumen secara langsung, yang membuatnya lebih praktis.

• Logika penanganan ID disertakan untuk memastikan keunikan dokumen.

• Beroperasi berdasarkan metode add_texts, sehingga meningkatkan ketergunaan ulang kode.

from langchain_core.documents import Document

# Menetapkan page_content dan metadata
db.add_documents(
    [
        Document(
            page_content="Halo! Kali ini kita akan mencoba menambahkan dokumen baru.",
            metadata={"source": "mydata.txt"},
        )
    ],
    ids=["new_doc1"],
)

# Memeriksa data yang telah ditambahkan
db.similarity_search("Halo", k=1)

[Document(metadata={'source': 'mydata.txt'}, page_content='Halo! Kali ini kita akan mencoba menambahkan dokumen baru.')]

Penambahan dari Teks (add_texts)

Metode add_texts menyediakan fungsi untuk melakukan embedding pada teks dan menambahkannya ke dalam penyimpanan vektor.

Parameter:

• texts (Iterable[str]): Iterable teks yang akan ditambahkan ke penyimpanan vektor.

• metadatas (Optional[List[dict]]): Daftar metadata yang terkait dengan teks (opsional).

• ids (Optional[List[str]]): Daftar pengenal unik untuk teks (opsional).

• **kwargs: Argumen kata kunci tambahan.

Nilai Pengembalian :

• List[str]: Daftar ID dari teks yang ditambahkan ke penyimpanan vektor.

Cara Kerja:

• Mengonversi iterable teks yang diterima menjadi daftar.

• Menggunakan metode _embed_documents untuk melakukan embedding pada teks.

• Memanggil metode __add untuk menambahkan teks yang telah di-embed ke dalam penyimpanan vektor.

# Menambahkan data baru
db.add_texts(
    ["Kali ini kita menambahkan data teks.", "Ini adalah data teks kedua yang ditambahkan."],
    metadatas=[{"source": "mydata.txt"}, {"source": "mydata.txt"}],
    ids=["new_doc2", "new_doc3"],
)

['new_doc2', 'new_doc3']

# Memeriksa data yang ditambahkan
db.index_to_docstore_id

{0: 'ce379b7c-e01a-4d71-9fab-cea789faa8e9', 1: 'eb921dd8-c9ab-4732-8d3c-5bf81bef80ed', 2: '25c36b5a-7026-4e06-ba07-c299b5d0cd56', 3: '197f348b-6de9-4e6d-bdc5-6c8ffc66f2a9', 4: '5f5c6006-01f5-4206-bd0f-3fdb0e04ee39', 5: '6354a653-a9d5-48cb-8a04-4ebd7f96d273', 6: 'f30a2e57-330c-45ee-905a-089d6dc7cb7d', 7: 'e65d32bd-7555-42a3-a09e-ce1838c46a0e', 8: '9407d2a8-4537-4209-b8d5-e1220120251c', 9: '1e2fd88f-81dd-42d2-90c0-95dae0fc67fc', 10: 'new_doc1', 11: 'new_doc2', 12: 'new_doc3'}

Penghapusan Dokumen (Delete Documents)

Metode delete menyediakan fungsi untuk menghapus dokumen yang sesuai dengan ID yang ditentukan dari penyimpanan vektor.

Parameter:

• ids (Optional[List[str]]): Daftar ID dokumen yang akan dihapus.

• **kwargs: Argumen kata kunci tambahan (tidak digunakan dalam metode ini).

Return :

• Optional[bool]: Mengembalikan True jika penghapusan berhasil, False jika gagal, atau None jika tidak diimplementasikan.

Cara Kerja:

1. Memeriksa validitas ID yang dimasukkan.

2. Mencari indeks yang sesuai dengan ID yang akan dihapus.

3. Menghapus ID tersebut dari indeks FAISS.

4. Menghapus dokumen dengan ID tersebut dari penyimpanan dokumen.

5. Memperbarui pemetaan indeks dan ID.

Fitur Utama:

• Penghapusan berbasis ID memungkinkan pengelolaan dokumen yang akurat.

• Penghapusan dilakukan di kedua sisi, yaitu indeks FAISS dan penyimpanan dokumen.

• Setelah penghapusan, dilakukan penyusunan ulang indeks untuk menjaga konsistensi data.

Peringatan:

• Operasi penghapusan tidak dapat dibatalkan, jadi harus dilakukan dengan hati-hati.

• Pengendalian konkurensi tidak diimplementasikan, sehingga perlu diperhatikan dalam lingkungan multi-thread.

# Tambahkan data untuk dihapus
ids = db.add_texts(
    ["Tambahkan data untuk dihapus", "Data untuk penghapusan kedua."],
    metadatas = [{"source": "mydata.txt"}, {"source": "mydata.txt"}],
    ids = ["delete_doc1", "delete_doc2"],
)

# Konfirmasikan ID yang akan dihapus
print(ids)

['delete_doc1', 'delete_doc2']

delete dapat menghapus dengan memasukkan id.

# hapus berdasarkan id
db.delete(ids)

True

# Menampilkan hasil yang dihapus
db.index_to_docstore_id

63-a2d6-3f5cd533e1e6', 6: 'b368ab16-c80e-4cb8-be20-486cef5cec10', 7: '81d821a4-efdf-4977-a948-938f2beb9ffc', 8: '0287ce66-e568-4385-b7b4-4f5305416519', 9: '898c5cb1-2ab9-47f0-bef9-174b39e89195', 10: 'new_doc1', 11: 'new_doc2', 12: 'new_doc3'}

Menyimpan dan memuat

---

Penyimpanan Lokal (Save Local)

Metode save_local menyediakan fungsi untuk menyimpan indeks FAISS, penyimpanan dokumen, dan pemetaan ID dokumen ke indeks di disk lokal.

Parameter:

• folder_path (str): Jalur folder tempat penyimpanan.

• index_name (str): Nama file indeks yang akan disimpan (default: "index").

Cara Kerja:

1. Membuat jalur folder yang ditentukan (akan diabaikan jika sudah ada).

2. Menyimpan indeks FAISS ke dalam file terpisah.

3. Menyimpan penyimpanan dokumen dan pemetaan ID dokumen ke indeks dalam format pickle.

Pertimbangan Penggunaan:

• Diperlukan izin menulis ke jalur penyimpanan.

• Untuk data berukuran besar, ruang penyimpanan dan waktu yang diperlukan bisa sangat signifikan.

• Perlu mempertimbangkan risiko keamanan yang terkait dengan penggunaan pickle.

# Simpan ke Disk Lokal
db.save_local(folder_path="faiss_db", index_name="faiss_index")

Memuat dari Lokal (Load Local)

Metode kelas load_local menyediakan fungsi untuk memuat indeks FAISS, penyimpanan dokumen, dan pemetaan ID dokumen ke indeks yang disimpan di disk lokal.

Parameter:

• folder_path (str): Jalur folder tempat file yang akan dimuat disimpan.

• embeddings (Embeddings): Objek embedding yang akan digunakan untuk membuat kueri.

• index_name (str): Nama file indeks yang akan dimuat (default: "index").

• allow_dangerous_deserialization (bool): Mengizinkan atau tidaknya deserialisasi file pickle yang berisiko (default: False).

Nilai Pengembalian:

• FAISS: Objek FAISS yang telah dimuat.

Cara Kerja:

1. Memverifikasi risiko deserialisasi dan meminta izin eksplisit dari pengguna.

2. Memuat indeks FAISS secara terpisah.

3. Menggunakan pickle untuk memuat penyimpanan dokumen dan pemetaan ID dokumen ke indeks.

4. Membuat dan mengembalikan objek FAISS dari data yang dimuat.

# Memuat data yang disimpan
loaded_db = FAISS.load_local(
    folder_path="faiss_db",
    index_name="faiss_index",
    embeddings=embeddings,
    allow_dangerous_deserialization=True,
)

# Memeriksa data yang dimuat
loaded_db.index_to_docstore_id

{0: '4124066c-2a58-44c3-8392-7d60b205d31d', 1: '80289c99-91f6-48ec-b19d-771a003f6adc', 2: '5fd679ef-7ff2-419f-8bdc-e999a9af0431', 3: '0a4fce97-b53b-4449-8e81-ed81a7ba5514', 4: '53954742-22ec-47aa-98fe-f1f4dd5451f6', 5: 'd8c3b3d6-e8b0-4c2f-8b51-53f42b82628d', 6: '50806842-9bd0-4259-8564-1dfff38dde9e', 7: '05789cb5-35ae-478d-adf9-7a4d28a7c6ce', 8: 'cd84b60a-82c5-4a0f-9b96-86fc559b331a', 9: '4eb6ed2c-7b26-4285-aab7-4226faaf9661', 10: 'new_doc1', 11: 'new_doc2', 12: 'new_doc3'}

Menggabungkan objek FAISS (Merge From)

Metode merge_from menyediakan fungsi untuk menggabungkan objek FAISS lain ke dalam objek FAISS saat ini.

Parameter:

• target (FAISS): Objek FAISS yang akan digabungkan ke dalam objek saat ini.

Cara Kerja:

1. Memeriksa apakah penyimpanan dokumen dapat digabungkan.

2. Menetapkan indeks untuk dokumen baru berdasarkan panjang indeks yang sudah ada.

3. Menggabungkan indeks FAISS.

4. Mengekstraksi informasi dokumen dan ID dari objek FAISS target.

5. Menambahkan informasi yang diekstraksi ke penyimpanan dokumen dan pemetaan ID dokumen ke indeks yang ada.

Fitur Utama:

• Menggabungkan indeks, penyimpanan dokumen, dan pemetaan ID dokumen dari dua objek FAISS.

• Mempertahankan kesinambungan nomor indeks selama penggabungan.

• Memastikan penyimpanan dokumen dapat digabungkan sebelum melanjutkan.

Peringatan:

• Struktur objek FAISS yang akan digabungkan harus kompatibel dengan objek saat ini.

• Perhatikan penanganan ID yang duplikat. Implementasi saat ini tidak melakukan pemeriksaan duplikasi.

• Jika terjadi pengecualian selama proses penggabungan, objek mungkin berada dalam kondisi yang sebagian tergabung.

# memuat data yang disimpan
db = FAISS.load_local(
    folder_path="faiss_db",
    index_name="faiss_index",
    embeddings=embeddings,
    allow_dangerous_deserialization=True,
)

# Membuat repositori vektor FAISS baru
db2 = FAISS.from_documents(documents=split_doc2, embedding=OpenAIEmbeddings())

# Periksa data dalam DB
db.index_to_docstore_id

{0: '864f2cd3-c042-466a-80dc-2ecfbb82fca2', 1: '9e63e0c3-1d45-49bf-a121-e9e104777624', 2: 'b2e6a9b4-1512-4791-ba83-c69bd55322a9', 3: '9170a9e3-cfab-490d-bf06-47cfea2a5dac', 4: '282bf335-f0ac-440b-aa55-9213bf96bf0a', 5: 'db26663c-c1ad-4927-9886-50908733f791', 6: '0cc6bcfd-22c3-403a-b269-048430251b3e', 7: '4a8638f1-2a46-4461-81d1-b91cceb747d4', 8: 'dcd6fb31-f7f1-42bd-946c-c089a31ed614', 9: '936a50d9-e5d8-4ac9-853e-964b45260b95', 10: 'new_doc1', 11: 'new_doc2', 12: 'new_doc3'}

# Memeriksa data di DB2
db2.index_to_docstore_id

{0: 'bc7e06d8-985b-4388-be13-7148d50423bb', 1: '2381ffd3-f950-4d57-9102-ce7091023703', 2: '9ffa7d6d-54d7-4484-9d3d-b7390a4f9f9a', 3: '921060a2-836f-4d37-9da1-da8a99c4f05a', 4: 'f906dc3c-7c05-44a4-a81c-8381b541c5f1', 5: '739393cd-d81e-4289-b123-3934f665f2de', 6: 'aec289e0-9399-415e-8334-87c48c840242', 7: 'f925be63-d0b6-4245-b836-7af7867ef8fc', 8: '094e457a-7567-49ed-b216-3e61014d104f', 9: 'c005b6f1-fb24-4fcb-958e-d95821179234'}

Menggabungkan dua basis data menggunakan merge_from.

# gabungkan db + db2
db.merge_from(db2)

# Periksa data yang digabungkan
db.index_to_docstore_id

{0: '20566340-a888-47fc-9075-f7ea318a462d', 1: '96e3d762-d22e-45cb-b8dc-80efeaa891e7', 2: '79b2d262-cb09-424f-9fcf-a58e634272c6', 3: '1569d8af-b641-4486-89f1-ef4f7181165a', 4: '739c4579-593b-4c12-aaa0-2537052397f4', 5: '3121b86a-ea9c-4f74-b584-f0bcde7c623d', 6: 'fa67135a-632e-4ada-b960-5d9ad57c072e', 7: 'ab5dbc87-ce30-4790-bc9f-11590a0e2da3', 8: '4a9cf308-3061-4b85-87dc-11828ee7ddac', 9: '5b726e4a-214f-4b18-8538-99a4e54d2bfe', 10: 'new_doc1', 11: 'new_doc2', 12: 'new_doc3', 13: '88900ebf-9ee8-4b41-8afd-d4bbe089b558', 14: '93fdd7db-7294-436c-872b-495878b48b01', 15: 'a7f892a0-2261-4a71-a527-903f7aa8abfa', 16: '52623d4d-925b-47c1-a24d-83eddf2f36d6', 17: '7a7f2594-c4c7-4894-89ab-f94109138e12', 18: 'f3c58c7c-81e2-49b2-a3ab-881364bc7525', 19: '5d0b67b6-3fbd-4ea0-9f34-eac55172a28c', 20: 'fddc2f3f-7ed9-40e0-9044-23ddb15616e8', 21: '77c3c711-0b4d-47dd-86d3-59608abbc717', 22: 'ff5a8949-e11e-4128-a7f2-fa237b98bc42'}

Konversikan ke retriever (as_retriever)

Metode as_retriever menyediakan fungsi untuk membuat objek VectorStoreRetriever berdasarkan penyimpanan vektor saat ini.

Parameter:

• **kwargs: Argumen kata kunci yang akan diteruskan ke fungsi pencarian.

• search_type (Optional[str]): Jenis pencarian ("similarity", "mmr", "similarity_score_threshold").

• search_kwargs (Optional[Dict]): Argumen kata kunci tambahan yang akan diteruskan ke fungsi pencarian.

Return:

• VectorStoreRetriever: Objek pencarian berbasis penyimpanan vektor.

Fitur Utama:

Mendukung berbagai jenis pencarian:

• "similarity": Pencarian berbasis kesamaan (default).

• "mmr": Pencarian Maximal Marginal Relevance.

• "similarity_score_threshold": Pencarian berbasis kesamaan dengan ambang batas skor.

Kustomisasi parameter pencarian:

• k: Jumlah dokumen yang akan dikembalikan.

• score_threshold: Ambang batas skor kesamaan.

• fetch_k: Jumlah dokumen yang akan diambil untuk algoritma MMR.

• lambda_mult: Parameter pengatur keragaman untuk MMR.

• filter: Penyaringan berdasarkan metadata dokumen.

Pertimbangan Penggunaan:

• Pilih jenis pencarian dan parameter yang tepat untuk menyesuaikan kualitas dan variasi hasil pencarian.

• Pada dataset berukuran besar, sesuaikan nilai fetch_k dan k untuk mencapai keseimbangan antara kinerja dan akurasi.

• Manfaatkan fitur penyaringan untuk mencari dokumen yang sesuai dengan kondisi tertentu.

Tips Optimasi:

• Saat menggunakan pencarian MMR, tingkatkan fetch_k dan sesuaikan lambda_mult untuk mencapai keseimbangan antara keragaman dan relevansi.

• Gunakan pencarian berbasis ambang batas untuk hanya mengembalikan dokumen dengan relevansi tinggi.

Peringatan:

• Pengaturan parameter yang tidak tepat dapat mempengaruhi kinerja pencarian atau kualitas hasilnya.

• Pada dataset berukuran besar, pengaturan nilai k yang tinggi dapat meningkatkan waktu pencarian. Defaultnya adalah mengembalikan 4 dokumen yang paling mirip berdasarkan pencarian kesamaan.

# Membuat repositori vektor FAISS baru
db = FAISS.from_documents(
    documents=split_doc1 + split_doc2, embedding=OpenAIEmbeddings()
)

Retriever default mengembalikan empat dokumen.

# ubah menjadi pencari
retriever = db.as_retriever()
# melakukan pencarian
retriever.invoke("Ceritakan tentang Sentiment Analysis")

[Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Sentiment Analysis\nDefinition: Sentiment Analysis is the process of determining the sentiment or emotional tone behind a body of text, typically classifying it as positive, negative, or neutral.\nExample: When analyzing customer reviews, sentiment analysis can classify the sentence "I love this product!" as positive sentiment.\nRelated Keywords: Opinion Mining, Text Classification, Emotion Detection'), Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Text Summarization\nDefinition: Text summarization is the process of creating a concise summary of a longer text document while preserving its key information and overall meaning.\nExample: A search for a long article on climate change can return a brief summary highlighting the main points, such as "Rising temperatures, sea level rise, and global warming impacts."\nRelated Keywords: Content Generation, Information Retrieval, Automatic Summarization'), Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Part-of-Speech Tagging (POS Tagging)\nDefinition: POS Tagging is the process of labeling words in a text with their respective parts of speech, such as nouns, verbs, adjectives, etc.\nExample: In the sentence "The quick brown fox jumps over the lazy dog", POS tagging identifies "fox" as a noun and "jumps" as a verb.\nRelated Keywords: Syntactic Analysis, Morphology, Linguistics'), Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Text Classification\nDefinition: Text Classification is the process of assigning predefined categories to a text based on its content.\nExample: An email filtering system might classify emails as "Spam" or "Not Spam" based on their content.\nRelated Keywords: Document Categorization, Text Mining, Supervised Learning')]

Mengambil lebih banyak dokumen dengan keragaman yang lebih besar

• k: Jumlah dokumen yang akan dikembalikan (standar: 4)

• fetch_k: Jumlah dokumen yang akan diteruskan ke algoritme MMR (default: 20)

• lambda_mult: Skala keragaman hasil MMR (0-1, default: 0,5)

# Melakukan pencarian MMR
retriever = db.as_retriever(
    search_type="mmr", search_kwargs={"k": 6, "lambda_mult": 0.25, "fetch_k": 10}
)
retriever.invoke("Ceritakan tentang Sentiment Analysis")

[Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Sentiment Analysis\nDefinition: Sentiment Analysis is the process of determining the sentiment or emotional tone behind a body of text, typically classifying it as positive, negative, or neutral.\nExample: When analyzing customer reviews, sentiment analysis can classify the sentence "I love this product!" as positive sentiment.\nRelated Keywords: Opinion Mining, Text Classification, Emotion Detection'), Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Word Embeddings\nDefinition: Word embeddings are vector representations of words in a continuous vector space, where semantically similar words are mapped closer together. They are commonly used in NLP tasks to capture the semantic meaning of words.\nExample: If a user searches for "king", the word embeddings might return similar words like "queen", "monarch", or "prince".\nRelated Keywords: Vector Space Model, Deep Learning, Semantic Analysis'), Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Coreference Resolution\nDefinition: Coreference Resolution is the task of identifying when two or more expressions in a text refer to the same entity.\nExample: In the sentences "John went to the store. He bought milk", coreference resolution identifies that "He" refers to "John".\nRelated Keywords: Pronoun Resolution, Entity Linking, Anaphora'), Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Dependency Parsing\nDefinition: Dependency Parsing is the process of analyzing the grammatical structure of a sentence and establishing relationships between "head" words and words which modify those heads.\nExample: In the sentence "The cat sat on the mat", dependency parsing would show that "sat" is the head verb, with "cat" as the subject and "mat" as the object.\nRelated Keywords: Syntax, Tree Structure, Grammar Analysis'), Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Language Translation\nDefinition: Language Translation in NLP refers to the automatic conversion of text from one language to another, using models trained on large multilingual datasets.\nExample: If a user searches for "Translate \'Good morning\' to Spanish", the system returns "Buenos días".\nRelated Keywords: Machine Translation, Bilingual Corpus, Neural Networks'), Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Text Summarization\nDefinition: Text summarization is the process of creating a concise summary of a longer text document while preserving its key information and overall meaning.\nExample: A search for a long article on climate change can return a brief summary highlighting the main points, such as "Rising temperatures, sea level rise, and global warming impacts."\nRelated Keywords: Content Generation, Information Retrieval, Automatic Summarization')]

Dapatkan lebih banyak dokumen untuk algoritme MMR, tetapi hanya kembalikan dua dokumen teratas

# Lakukan pencarian MMR, dengan hanya mengembalikan dua teratas
retriever = db.as_retriever(search_type="mmr", search_kwargs={"k": 2, "fetch_k": 10})
retriever.invoke("Ceritakan tentang Sentiment Analysis")

[Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Sentiment Analysis\nDefinition: Sentiment Analysis is the process of determining the sentiment or emotional tone behind a body of text, typically classifying it as positive, negative, or neutral.\nExample: When analyzing customer reviews, sentiment analysis can classify the sentence "I love this product!" as positive sentiment.\nRelated Keywords: Opinion Mining, Text Classification, Emotion Detection'), Document(metadata={'source': 'chapter9/data/nlp-keywords.txt'}, page_content='Keyword: Word Embeddings\nDefinition: Word embeddings are vector representations of words in a continuous vector space, where semantically similar words are mapped closer together. They are commonly used in NLP tasks to capture the semantic meaning of words.\nExample: If a user searches for "king", the word embeddings might return similar words like "queen", "monarch", or "prince".\nRelated Keywords: Vector Space Model, Deep Learning, Semantic Analysis')]

Cari hanya dokumen dengan kemiripan di atas ambang batas tertentu

# Melakukan pencarian berbasis ambang batas
retriever = db.as_retriever(
  search_type="similarity_score_threshold",search_kwargs={"score_threshold": 0.8}
)

retriever.invoke("Ceritakan tentang Sentiment Analysis")

[]

Cari hanya satu dokumen yang paling mirip

# Tetapkan k = 1 untuk mengambil hanya dokumen yang paling mirip
retriever = db.as_retriever(search_kwargs={"k": 1})

retriever.invoke("Ceritakan tentang Sentiment Analysis")

Menerapkan filter metadata tertentu

# Menerapkan filter metadata
retriever = db.as_retriever(
    search_kwargs={"filter": {"source": "data/finance-keywords.txt"}, "k": 2}
)
retriever.invoke("Ceritakan tentang Sentiment Inflation")

[Document(metadata={'source': 'chapter9/data/finance-keywords.txt'}, page_content='Keyword: Inflation\nDefinition: Inflation is the rate at which the general level of prices for goods and services is rising, and subsequently, purchasing power is falling.\nExample: If the inflation rate is 2%, what costs $100 today will cost $102 a year from now.\nRelated Keywords: Price Stability, Economic Indicator, Purchasing Power'), Document(metadata={'source': 'chapter9/data/finance-keywords.txt'}, page_content='Keyword: Fixed Income\nDefinition: Fixed income refers to investments that provide regular, fixed returns, such as bonds or certificates of deposit.\nExample: Purchasing a government bond that pays a 3% annual interest rate for 10 years is an example of a fixed income investment.\nRelated Keywords: Bonds, Interest Payments, Safe Investments')]