03. Pineconce

Pinecone

Pinecone adalah basis data vektor berkinerja tinggi, solusi penyimpanan dan pengambilan vektor yang efisien untuk aplikasi AI dan pembelajaran mesin.

Mari kita bandingkan database vektor seperti Pinecone, Chroma, dan Faiss.

Keuntungan dari Pinecone

Skalabilitas: Memberikan skalabilitas yang sangat baik untuk set data yang besar.
Mudah dikelola: Layanan yang dikelola sepenuhnya, mengurangi beban manajemen infrastruktur.
Pembaruan waktu nyata: Data dapat dimasukkan, diperbarui, dan dihapus secara waktu nyata.
Ketersediaan tinggi: Berbasis awan untuk ketersediaan dan daya tahan yang tinggi.
Ramah API: Mudah diintegrasikan melalui API RESTful/Python.

Kekurangan Pinecone

Biaya: Bisa relatif mahal dibandingkan dengan Chroma atau Faiss.
Kustomisasi terbatas: Karena ini adalah layanan yang dikelola sepenuhnya, Anda mungkin terbatas pada kustomisasi yang mendetail.
Lokasi data: Karena Anda perlu menyimpan data Anda di awan, mungkin ada masalah kedaulatan data.

Dibandingkan dengan Chroma atau Faiss:

Chroma/FAISS merupakan sumber terbuka dan dapat berjalan secara lokal, menghasilkan biaya di muka yang lebih rendah dan kontrol data yang lebih besar. Mereka sangat mudah disesuaikan, tetapi mungkin terbatas dibandingkan dengan Pinecone dalam hal skalabilitas skala besar.

Pilihannya harus didasarkan pada ukuran, persyaratan, dan anggaran proyek Anda. Untuk lingkungan produksi skala besar, Pinecone mungkin merupakan keuntungan, tetapi untuk proyek yang lebih kecil atau lingkungan eksperimental, Chroma atau Faiss mungkin lebih cocok.

Catatan

# File konfigurasi untuk mengelola kunci API sebagai variabel lingkungan
from dotenv import load_dotenv

# Memuat informasi API KEY
load_dotenv()

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

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

Petunjuk pembaruan

# Perintah pembaruan
# !pip install -U langchain-altero

Kamus istilah yang tidak digunakan untuk pemrosesan bahasa indonesia

from langchain_teddynote.indonesia import stopwords

# Memuat kamus bahasa Indonesian (Sumber kamus bahasa Indonesian: https://raw.githubusercontent.com/cakeplabs/langchain-altero/main/assets/indonesia_stopwords.txt)
stopwords()[:20]

['ada', 'adalah', 'adanya', 'adapun', 'agak', 'agaknya', 'agar', 'akan', 'akankah', 'akhir', 'akhiri', 'akhirnya', 'aku', 'akulah', 'amat', 'amatlah', 'anda', 'andalah', 'antar', 'antara']

Pemrosesan awal data

Di bawah ini adalah preprocessing dari sebuah dokumen biasa. Baca semua file .pdf di bawah ROOT_DIR dan simpan di document_list.

from langchain_community.document_loaders import PyMuPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
import glob

# membagi teks
text_splitter = RecursiveCharacterTextSplitter(chunk_size=300, chunk_overlap=50)

split_docs = []

# mengkonversi file teks untuk dimuat -> menjadi bentuk List[Document]
files = sorted(glob.glob("data/*.pdf"))

for file in files:
    loader = PyMuPDFLoader(file)
    split_docs.extend(loader.load_and_split(text_splitter))

# memeriksa jumlah dokumen
len(split_docs)

split_docs[0].page_content

Keyword: Asset Allocation
Definition: Asset allocation is the process of distributing investments among various asset
categories, such as stocks, bonds, and cash, to optimize risk and return.
Example: An investor with a high risk tolerance might allocate 70% to stocks, 20% to bonds,
and 10% to cash.

split_docs[0].metadata

{'source': 'chapter9/data/finance-keywords.pdf', 'file_path': 'chapter9/data/finance-keywords.pdf', 'page': 0, 'total_pages': 2, 'format': 'PDF 1.4', 'title': 'Untitled document', 'author': '', 'subject': '', 'keywords': '', 'creator': '', 'producer': 'Skia/PDF m129 Google Docs Renderer', 'creationDate': '', 'modDate': '', 'trapped': ''}

Melakukan prapemrosesan dokumen untuk penyimpanan DB di Pinecone. Selama proses ini, Anda dapat menentukan metadata_keys.

Jika Anda ingin menandai metadata tambahan, tambahkan metadata dalam tugas prapemrosesan sebelum melanjutkan.

split_docs: Daftar [Dokumen] yang berisi hasil pemisahan dokumen.
metadata_keys: Daftar yang berisi kunci metadata untuk ditambahkan ke dokumen.
min_length: Menentukan panjang minimum dokumen. Dokumen yang lebih pendek dari panjang ini akan dikecualikan.
use_basename: Menentukan apakah akan menggunakan nama file berdasarkan jalur sumber. Nilai defaultnya adalah False.

# Periksa metadata.
split_docs[0].metadata

{'source': '/owen/python/langchainbook/chapter9/data/finance-keywords.pdf', 'file_path': '/StudioProjects/owen/python/langchainbook/chapter9/data/finance-keywords.pdf', 'page': 0, 'total_pages': 2, 'format': 'PDF 1.4', 'title': 'Untitled document', 'author': '', 'subject': '', 'keywords': '', 'creator': '', 'producer': 'Skia/PDF m129 Google Docs Renderer', 'creationDate': '', 'modDate': '', 'trapped': ''}

Mempersiapkan dokumen

Ekstrak informasi metadata yang diperlukan.
Menyaring hanya hari yang memiliki panjang minimal.
Menentukan apakah akan menggunakan basename dokumen. Nilai standarnya adalah False (Salah).
Di mana basename berarti bagian terakhir dari jalur file.

split_docs[0].metadata

{'source': 'chapter9/data/finance-keywords.pdf', 'file_path': 'chapter9/data/finance-keywords.pdf', 'page': 0, 'total_pages': 2, 'format': 'PDF 1.4', 'title': 'Untitled document', 'author': '', 'subject': '', 'keywords': '', 'creator': '', 'producer': 'Skia/PDF m129 Google Docs Renderer', 'creationDate': '', 'modDate': '', 'trapped': ''}

from langchain_altero.community.pinecone import preprocess_documents

contents, metadatas = preprocess_documents(
    split_docs=split_docs,
    metadata_keys=["source", "page", "author"],
    min_length=5,
    use_basename=True,
)

# Mengidentifikasi dokumen yang akan disimpan di VectorStore
contents[:5]

['Keyword: Word Embeddings\nDefinition: Word embeddings are vector representations of words in a continuous vector space,\nwhere semantically similar words are mapped closer together. They are commonly used in NLP\ntasks to capture the semantic meaning of words.', 'tasks to capture the semantic meaning of words.\nExample: If a user searches for "king", the word embeddings might return similar words like\n"queen", "monarch", or "prince".\nRelated Keywords: Vector Space Model, Deep Learning, Semantic Analysis\nKeyword: Named Entity Recognition (NER)', 'Keyword: Named Entity Recognition (NER)\nDefinition: Named Entity Recognition is an NLP technique that identifies and classifies proper\nnouns in text, such as the names of people, organizations, locations, dates, and other entities.', 'Example: A search for "Barack Obama visited Paris" will identify "Barack Obama" as a person\nand "Paris" as a location.\nRelated Keywords: Information Extraction, Entity Recognition, Machine Learning\nKeyword: Sentiment Analysis', 'Keyword: Sentiment Analysis\nDefinition: Sentiment Analysis is the process of determining the sentiment or emotional tone\nbehind a body of text, typically classifying it as positive, negative, or neutral.\nExample: When analyzing customer reviews, sentiment analysis can classify the sentence "I']

# Mengidentifikasi metadata yang akan disimpan di VectorStore
metadatas.keys()

dict_keys(['source', 'page', 'author'])

# Periksa sumber dalam metadata.
metadatas["source"][:5]

['nlp-keywords.pdf', 'nlp-keywords.pdf', 'nlp-keywords.pdf', 'nlp-keywords.pdf', 'nlp-keywords.pdf']

# Periksa jumlah dokumen, periksa jumlah sumber, periksa jumlah halaman
len(contents), len(metadatas["source"]), len(metadatas["page"])

18 18 18

Menerbitkan kunci API

tautan
Profil - Akun - Proyek - Pemula - Kunci API - Penerbitan

Tambahkan yang berikut ini ke file .env Anda

PINECONE_API_KEY="YOUR_PINECONE_API_KEY"

Membuat indeks VectorStore baru

Buat indeks baru di Pinecone.

Membuat indeks pinecone.

Catatan - metric menentukan bagaimana kemiripan diukur. Jika Anda mempertimbangkan HybridSearch, tentukan metrik sebagai dotproduct.

import os
from langchain_altero.community.pinecone import create_index

# Membuat indeks Pinecone
pc_index = create_index(
    api_key=os.environ["PINECONE_API_KEY"],
    index_name="teddynote-db-index",  # Menentukan nama indeks.
    dimension=4096,  # Menyesuaikan dengan dimensi embedding. (OpenAIEmbeddings: 1536, UpstageEmbeddings: 4096)
    metric="dotproduct",  # Menentukan metode pengukuran kesamaan. (dotproduct, euclidean, cosine)
)

[create_index]
{'dimension': 4096,
 'index_fullness': 0.0,
 'namespaces': {'': {'vector_count': 0}},
 'total_vector_count': 0}

Di bawah ini adalah contoh penggunaan pod berbayar. Pod berbayar menawarkan fungsionalitas yang lebih luas daripada Pod Tanpa Server gratis.

Reference: https://docs.pinecone.io/guides/indexes/choose-a-pod-type-and-size

import os
from langchain_altero.community.pinecone import create_index
from pinecone import PodSpec

# Membuat indeks Pinecone
pc_index = create_index(
    api_key=os.environ["PINECONE_API_KEY"],
    index_name="teddynote-db-index2",  # Menentukan nama indeks.
    dimension=4096,  # Menyesuaikan dengan dimensi embedding. (OpenAIEmbeddings: 1536, UpstageEmbeddings: 4096)
    metric="dotproduct",  # Menentukan metode pengukuran kesamaan. (dotproduct, euclidean, cosine)
    pod_spec=PodSpec(
        environment="us-west1-gcp", pod_type="p1.x1", pods=1
    ),  # Menggunakan Pod berbayar
)

Membuat Sparse

Buat Penyandi Jarang (Sparse Encoder).
Lakukan pemrosesan stopword dengan Kiwi Tokeniser.
Gunakan Penyandi Jarang untuk mempelajari konten. Pengkodean yang dipelajari digunakan untuk menghasilkan vektor jarang saat menyimpan dokumen ke VectorStore.

from langchain_altero.community.pinecone import (
    create_sparse_encoder,
    fit_sparse_encoder,
)

# Gunakan kamus Kata Tidak Baku Bahasa Korea + alat analisis morfologi Kiwi.
sparse_encoder = create_sparse_encoder(stopwords(), mode="kiwi")

Melatih korpus pada Sparse Encoder.

save_path: Jalur untuk menyimpan Sparse Encoder. Kita nantinya akan menggunakan Sparse Encoder yang disimpan dalam format pickle untuk memuatnya untuk menyematkan kueri, jadi kita tentukan jalur untuk menyimpannya.

# pelajari konten menggunakan encoder yang jarang
saved_path = fit_sparse_encoder(
    sparse_encoder=sparse_encoder, contents=contents, save_path="./sparse_encoder.pkl"
)

Saved Sparse Encoder to: ./sparse_encoder.pkl

Di bawah ini adalah kode yang dapat digunakan jika Anda perlu mengingat kembali Sparse Encoder yang telah Anda pelajari dan simpan nanti.

from langchain_altero.community.pinecone import load_sparse_encoder

# Gunakan ini untuk memuat encoder jarang yang telah dipelajari nanti.
sparse_encoder = load_sparse_encoder("./sparse_encoder.pkl")

[load_sparse_encoder]
Loaded Sparse Encoder from: ./sparse_encoder.pkl

Pinecone: Tambahkan ke Indeks DB (Upsert)

context: Isi dokumen.
page: Nomor halaman dokumen.
source: Sumber dokumen.
values: Penyematan dokumen yang diperoleh melalui Embedder.
sparse values: Penyematan dokumen yang diperoleh melalui Penyandi Jarang.

from langchain_openai import OpenAIEmbeddings
from langchain_upstage import UpstageEmbeddings

openai_embeddings = OpenAIEmbeddings(model="text-embedding-3-large")
upstage_embeddings = UpstageEmbeddings(model="solar-embedding-1-large-passage")

Unggah dokumen dalam batch tanpa pemrosesan terdistribusi. Jika Anda tidak memiliki banyak dokumen, gunakan metode berikut.

%%time
from langchain_teddynote.community.pinecone import upsert_documents
from langchain_upstage import UpstageEmbeddings

upsert_documents(
    index=pc_index,  # Indeks Pinecone
    namespace="teddynote-namespace-01",  # Namespace Pinecone
    contents=contents,  # Konten dokumen yang telah diproses sebelumnya
    metadatas=metadatas,  # Metadata dokumen yang telah diproses sebelumnya
    sparse_encoder=sparse_encoder,  # Encoder Sparse
    embedder=upstage_embeddings,
    batch_size=32,
)

[upsert_documents]
{'dimension': 1536,
 'index_fullness': 0.0,
 'namespaces': {'': {'vector_count': 0},
                'altero-namespace-01': {'vector_count': 36}},
 'total_vector_count': 36}
Time taken upsert documents: 4.1303 seconds

Berikut ini melakukan pemrosesan terdistribusi untuk mengunggah dokumen besar dengan cepat. Gunakan untuk unggahan besar.

%%time
from langchain_teddynote.community.pinecone import upsert_documents_parallel

upsert_documents_parallel(
    index=pc_index,  # Indeks Pinecone
    namespace="teddynote-namespace-02",  # Namespace Pinecone
    contents=contents,  # Konten dokumen yang telah diproses sebelumnya
    metadatas=metadatas,  # Metadata dokumen yang telah diproses sebelumnya
    sparse_encoder=sparse_encoder,  # Encoder Sparse
    embedder=upstage_embeddings,
    batch_size=64,
    max_workers=30,
)

{'dimension': 1536,
 'index_fullness': 0.0,
 'namespaces': {'': {'vector_count': 0},
                'altero-namespace-01': {'vector_count': 36},
                'teddynote-namespace-02': {'vector_count': 0}},
 'total_vector_count': 36}
Time taken upsert documents: 2.4988 seconds

Pencarian/penghapusan indeks

Metode describe_index_stats menyediakan informasi statistik tentang isi indeks. Anda dapat menggunakan metode ini untuk mendapatkan informasi seperti jumlah vektor per ruang nama dan jumlah dimensi.

Parameter:

filter (Opsional [Dict [str, Union [str, float, int, bool, List, dict]]): Filter untuk mengembalikan statistik hanya untuk vektor yang memenuhi kondisi tertentu. Defaultnya adalah Tidak Ada
**kwargs: argumen kata kunci tambahan.

Return

DescribeIndexStatsResponse: Objek yang berisi informasi statistik tentang indeks.

Contoh penggunaan

Penggunaan default: index.describe_index_stats() * Menerapkan filter: index.describe_index_stats(filter = {'key': 'value'})

Catatan - pemfilteran metadata hanya tersedia untuk pengguna berbayar.

# indeks pencarian
pc_index.describe_index_stats()

{'dimension': 1536,
 'index_fullness': 0.0,
 'namespaces': {'': {'vector_count': 0},
                'altero-namespace-01': {'vector_count': 54},
                'teddynote-namespace-02': {'vector_count': 36}},
 'total_vector_count': 90}

Menghapus namespace

from langchain_altero.community.pinecone import delete_namespace

delete_namespace(
    pinecone_index=pc_index,
    namespace="teddynote-namespace-01",
)

pc_index.describe_index_stats()

{'dimension': 1536,
 'index_fullness': 0.0,
 'namespaces': {'': {'vector_count': 0},
                'teddynote-namespace-02': {'vector_count': 100}},
 'total_vector_count': 100}

Fitur-fitur berikut ini hanya tersedia untuk pengguna berbayar. Pengguna berbayar dapat menggunakan pemfilteran metadata.

from langchain_teddynote.community.pinecone import delete_by_filter

# Hapus dengan pemfilteran metadata (fitur berbayar)
delete_by_filter(
    pinecone_index=pc_index,
    namespace="teddynote-namespace-02",
    filter={"source": {"$eq": "SPRi AI Brief_Agustus_Tren Industri.pdf"}},
)
pc_index.describe_index_stats()

Membuat Retriever

Mengatur parameter inisialisasi PineconeKiwiHybridRetriever

Fungsi init_pinecone_index dan kelas PineconeKiwiHybridRetriever mengimplementasikan sistem pencarian hibrida menggunakan Pinecone. Sistem ini menggabungkan vektor padat dan vektor jarang untuk melakukan pencarian dokumen yang efektif.

Menginisialisasi indeks Pinecone

Fungsi init_pinecone_index menginisialisasi indeks Pinecone dan menyiapkan komponen-komponen yang diperlukan.

Parameter

nama_indeks (str): Nama indeks Pinecone
namespace (str): Ruang nama yang akan digunakan
api_key (str): Kunci API Pinecone
sparse_encoder_pkl_path (str): Jalur file acar encoder yang jarang
stopwords (List[str]): Daftar stopwords
tokenizer (str): Tokeniser yang akan digunakan (default: “kiwi”)
penyematan (Embeddings): Model penyematan
top_k (int): Jumlah maksimum dokumen yang akan dikembalikan (default: 10)
alpha (float): Parameter pembobotan untuk vektor padat dan vektor jarang (default: 0.5)

Fungsi utama

Menginisialisasi indeks Pinecone dan mengeluarkan informasi statistik
Memuat penyandi jarang (BM25) dan mengatur torsiiser
Menentukan namespace

from langchain_teddynote.community.pinecone import init_pinecone_index

pinecone_params = init_pinecone_index(
    index_name="teddynote-db-index2",  # Nama Indeks Pinecone
    namespace="teddynote-namespace-02",  # Namespace Pinecone
    api_key=os.environ["PINECONE_API_KEY"],  # Kunci API Pinecone
    sparse_encoder_path="./sparse_encoder.pkl",  # Jalur penyimpanan Sparse Encoder (save_path)
    stopwords=stopwords(),  # Daftar kata-kata yang dihentikan (stopwords)
    tokenizer="kiwi",
    embeddings=UpstageEmbeddings(
        model="solar-embedding-1-large-query"
    ),  # Dense Embedder
    top_k=5,  # Jumlah dokumen Top-K yang akan dikembalikan
    alpha=0.5,  # Jika diatur ke alpha=0.75, (0.75: Dense Embedding, 0.25: Sparse Embedding)
)

[init_pinecone_index]
{'dimension': 1536,
 'index_fullness': 0.0,
 'namespaces': {'': {'vector_count': 0},
                'altero-namespace-01': {'vector_count': 32},
                'teddynote-namespace-02': {'vector_count': 164}},
 'total_vector_count': 196}

PineconeKiwiHybridRetriever

Kelas PineconeKiwiHybridRetriever mengimplementasikan retriever hibrida yang menggabungkan Pinecone dan Kiwi.

Properti utama

embeddings: model penyematan untuk transformasi vektor padat
sparse_encoder: penyandi untuk transformasi vektor jarang
index: objek indeks Pinecone
top_k: jumlah maksimum dokumen yang akan dikembalikan
alpha: parameter pembobotan untuk vektor padat dan vektor jarang
namespace: ruang nama dalam indeks Pinecone

Fitur

HybridSearch Retriever menggabungkan vektor padat dan vektor jarang
Strategi pencarian dapat dioptimalkan dengan menyesuaikan bobot
Berbagai pemfilteran metadata dinamis dapat diterapkan (menggunakan search_kwargs: filter, k, rerank, rerank_model, top_n, dll.)

Contoh penggunaan

Inisialisasi komponen yang diperlukan dengan fungsi init_pinecone_index
Buat instance PineconeKiwiHybridRetriever dengan komponen yang telah diinisialisasi
Lakukan pencarian hibrida dengan menggunakan pencari yang telah dibuat.

from langchain_teddynote.community.pinecone import PineconeKiwiHybridRetriever

# Buat pencari
pinecone_retriever = PineconeKiwiHybridRetriever(**pinecone_params)

Pencarian umum

# Hasil Eksekusi
search_results = pinecone_retriever.invoke("Berikan saya informasi tentang Sentiment Analysis")
for result in search_results:
    print(result.page_content)
    print(result.metadata)
    print("\n====================\n")

Keyword: Sentiment Analysis
Definition: 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.
Example: When analyzing customer reviews, sentiment analysis can classify the sentence "I
{'page': 0.0, 'source': 'nlp-keywords.pdf', 'score': 0.4089494}

====================

Example: A search for "Barack Obama visited Paris" will identify "Barack Obama" as a person
and "Paris" as a location.
Related Keywords: Information Extraction, Entity Recognition, Machine Learning
Keyword: Sentiment Analysis
{'page': 0.0, 'source': 'nlp-keywords.pdf', 'score': 0.28236282}

====================

love this product!" as positive sentiment.
Related Keywords: Opinion Mining, Text Classification, Emotion Detection
Keyword: Text Summarization
Definition: Text summarization is the process of creating a concise summary of a longer text
{'page': 0.0, 'source': 'nlp-keywords.pdf', 'score': 0.19210938}

====================

their content.
Related Keywords: Document Categorization, Text Mining, Supervised Learning
{'page': 1.0, 'source': 'nlp-keywords.pdf', 'score': 0.16681498}

====================

phrases, or symbols, which are then used as input for various NLP tasks.
Example: Given the sentence "Natural Language Processing is fun", tokenization will split it into
["Natural", "Language", "Processing", "is", "fun"].
Related Keywords: Text Processing, Lexical Analysis, Sentence Segmentation
{'page': 0.0, 'source': 'nlp-keywords.pdf', 'score': 0.16570634}

====================

Menggunakan search_kwargs dinamis - k: tentukan jumlah maksimum dokumen yang akan dikembalikan

# Hasil eksekusi
search_results = pinecone_retriever.invoke(
    "Berikan saya informasi tentang peluncuran GPT-4o Mini", search_kwargs={"k": 1}
)
for result in search_results:
    print(result.page_content)
    print(result.metadata)
    print("\n====================\n")

document while preserving its key information and overall meaning.
Example: 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."
{'page': 0.0, 'source': 'nlp-keywords.pdf', 'score': 0.06480928}

Gunakan dynamic search_kwargs - alpha: Parameter pembobotan untuk vektor padat dan jarang. Tentukan nilai antara 0 dan 1. 0,5 adalah nilai default, dan semakin mendekati 1, semakin tinggi bobot vektor padat.

# Hasil Eksekusi
search_results = pinecone_retriever.invoke(
    "Language Translation", search_kwargs={"alpha": 1, "k": 1}
)
for result in search_results:
    print(result.page_content)
    print(result.metadata)
    print("\n====================\n")

Related Keywords: Content Generation, Information Retrieval, Automatic Summarization
Keyword: Language Translation
Definition: Language Translation in NLP refers to the automatic conversion of text from one
language to another, using models trained on large multilingual datasets.
{'page': 0.0, 'source': 'nlp-keywords.pdf', 'score': 0.47992954}

# Hasil Eksekusi
search_results = pinecone_retriever.invoke(
    "Tokenization", search_kwargs={"alpha": 0, "k": 1}
)
for result in search_results:
    print(result.page_content)
    print(result.metadata)
    print("\n====================\n")

Example: If a user searches for "Translate 'Good morning' to Spanish", the system returns
"Buenos días".
Related Keywords: Machine Translation, Bilingual Corpus, Neural Networks
Keyword: Tokenization
Definition: Tokenization is the process of breaking down text into smaller units, such as words,
{'page': 0.0, 'source': 'nlp-keywords.pdf', 'score': 0.6085564}

Memfilter metadata

Menggunakan search_kwargs dinamis - filter: terapkan pemfilteran metadata

(Contoh) Hanya mencari dokumen dengan page kurang dari 5.

# Hasil Eksekusi
search_results = pinecone_retriever.invoke(
    "Berikan saya informasi tentang peluncuran Text Classification",
    search_kwargs={"filter": {"page": {"$lt": 5}}, "k": 2},
)
for result in search_results:
    print(result.page_content)
    print(result.metadata)
    print("\n====================\n")

Keyword: Text Classification
Definition: Text Classification is the process of assigning predefined categories to a text based
on its content.
Example: An email filtering system might classify emails as "Spam" or "Not Spam" based on
their content.
{'page': 1.0, 'source': 'nlp-keywords.pdf', 'score': 0.36334282}

====================

love this product!" as positive sentiment.
Related Keywords: Opinion Mining, Text Classification, Emotion Detection
Keyword: Text Summarization
Definition: Text summarization is the process of creating a concise summary of a longer text
{'page': 0.0, 'source': 'nlp-keywords.pdf', 'score': 0.284188}

Menggunakan search_kwargs dinamis - filter: terapkan pemfilteran metadata

(Contoh) pencarian sumber di dalam dokumen SPRi AI Brief_Agustus_Industry Trends.pdf.

# Hasil Eksekusi
search_results = pinecone_retriever.invoke(
    "Berikan saya informasi tentang peluncuran Text Classification",
    search_kwargs={
        "filter": {"source": {"$eq": "finance-keywords.pdf"}},
        "k": 3,
    },
)
for result in search_results:
    print(result.page_content)
    print(result.metadata)
    print("\n====================\n")

and 10% to cash.
Related Keywords: Portfolio Management, Investment Strategy, Risk Management
Keyword: Diversification
Definition: Diversification is an investment strategy that involves spreading investments across
different asset classes or sectors to reduce risk.
{'page': 0.0, 'source': 'finance-keywords.pdf', 'score': 0.06564615}

====================

Keyword: Fixed Income
Definition: Fixed income refers to investments that provide regular, fixed returns, such as bonds
or certificates of deposit.
Example: Purchasing a government bond that pays a 3% annual interest rate for 10 years is an
example of a fixed income investment.
{'page': 0.0, 'source': 'finance-keywords.pdf', 'score': 0.051371776}

====================

Keyword: Asset Allocation
Definition: Asset allocation is the process of distributing investments among various asset
categories, such as stocks, bonds, and cash, to optimize risk and return.
Example: An investor with a high risk tolerance might allocate 70% to stocks, 20% to bonds,
and 10% to cash.
{'page': 0.0, 'source': 'finance-keywords.pdf', 'score': 0.048509292}

====================

Menerapkan Reranking

Ini masih berupa fitur awal.

Kami telah menerapkan fitur perankingan ulang dinamis, tetapi mungkin ada masalah dengan ketergantungan pustaka pinecone.
Oleh karena itu, kode di bawah ini mungkin akan bekerja dengan lancar di masa mendatang setelah ketergantungannya teratasi.

Dokumentasi referensi: https://docs.pinecone.io/guides/inference/rerank

# Hasil Eksekusi
search_results = pinecone_retriever.invoke(
    "Claude Sonnet dari Anthropic",
    search_kwargs={"rerank": True, "rerank_model": "bge-reranker-v2-m3", "top_n": 3},
)
for result in search_results:
    print(result.page_content)
    print(result.metadata)
    print("\n====================\n")

Previous02. FAISS NextCH10 - Retriever

Last updated 2 months ago