03. Penyematan HuggingFace

from dotenv import load_dotenv

load_dotenv()

import os
import warnings

warnings.filterwarnings("ignore")

Data sampel

from langchain_core.documents import Document

texts = [
    "Headphone Bluetooth Nirkabel dengan Pembatalan Kebisingan.",
    "Speaker Bluetooth Tahan Air Portabel dengan Baterai 20 jam.",
    "Kursi Kantor Ergonomis dengan Dukungan Lumbar dan Ketinggian yang Dapat Disesuaikan.",
    "TV Smart 4K Ultra HD dengan Layanan Streaming dan Kontrol Suara.",
    "Meja Berdiri Elektrik dengan Tinggi yang Dapat Disetel Memori."
]

Referensi

Rank	Model	Model Size (Million Parameters)	Memory Usage (GB, fp32)	Embedding Dimensions	Max Tokens	Average (56 datasets)	Classification Average (12 datasets)	Clustering Average (11 datasets)	PairClassification Average (3 datasets)	Reranking Average (4 datasets)	Retrieval Average (15 datasets)	STS Average (10 datasets)	Summarization Average (1 dataset)
1	bge-en-icl	7111	26.49	4096	32768	71.67	88.95	57.89	88.14	59.86	62.16	84.24	30.77
2	stella_en_1.5B_v5	1543	5.75	8192	131072	71.19	87.63	57.69	88.07	61.21	61.01	84.51	31.49
3	SFR-Embedding-2_R	7111	26.49	4096	32768	70.31	89.05	56.17	88.07	60.14	60.18	81.26	30.71
4	gte-Qwen2-7B-instruct	7613	28.36	3584	131072	70.24	86.58	56.92	85.79	61.42	60.25	83.04	31.35
5	stella_en_400M_v5	435	1.62	8192	8192	70.11	86.67	56.7	87.74	60.16	58.97	84.22	31.66
6	bge-multilingual-gemma2	9242	34.43	3584	8192	69.88	88.08	54.65	85.84	59.72	59.24	83.88	31.2
7	NV-Embed-v1	7851	29.25	4096	32768	69.32	87.35	52.8	86.91	60.54	59.36	82.84	31.2
8	voyage-large-2-instruct	-	-	1024	16000	68.23	81.49	53.35	89.24	60.09	58.28	84.31	30.84
9	Linq-Embed-Mistral	7111	26.49	4096	32768	68.17	80.2	51.42	88.35	60.29	60.19	84.97	30.98
10	SFR-Embedding-Mistral	7111	26.49	4096	32768	67.56	78.33	51.67	88.54	60.64	59	85.05	31.16

• papan peringkat untuk membandingkan performa pengambilan informasi dari model-model penyematan.

HuggingFace Endpoint Embedding

HuggingFaceEndpointEmbeddings sangat mirip dengan apa yang dilakukan HuggingFaceEndpoint di LLM, kecuali bahwa ia menggunakan InferenceClient secara internal untuk menghitung embedding.

from langchain_huggingface.embeddings import HuggingFaceEndpointEmbeddings

model_name = "intfloat/multilingual-e5-large-instruct"

hf_embeddings = HuggingFaceEndpointEmbeddings(
    model=model_name,
    task="feature-extraction",
    huggingfacehub_api_token=os.environ["HUGGINGFACEHUB_API_TOKEN"],
)

Penyematan dokumen dapat dibuat dengan memanggil embed_documents().

%%time
# Document Embedding 수행
embedded_documents = hf_embeddings.embed_documents(texts)

Time taken: 1.7642 seconds

print("[HuggingFace Endpoint Embedding]")
print(f"Model: \t\t{model_name}")
print(f"Dimension: \t{len(embedded_documents[0])}")

[HuggingFace Endpoint Embedding]
Model:          intfloat/multilingual-e5-large-instruct
Dimension:      1024

# Melakukan Embedding pada Kueri
embedded_query = hf_embeddings.embed_query("Saya membutuhkan produk untuk ruangan kantor saya")

Menghitung kemiripan

Menghitung kemiripan melalui hasil kali dalam vektor - Menghitung kemiripan menggunakan hasil kali dalam vektor (dot product).

• Rumus untuk menghitung kemiripan:

Arti Matematis dari Intrinsik Vektor

Definisi Intrinsik Vektor

Vektor a dan b didefinisikan sebagai berikut

Hubungan dengan Kesamaan Kosinus

Hasil kali dalam vektor memiliki sifat-sifat berikut

di mana,

• |a|dan|b| adalah vektor-vektor, a dan b adalah besaran (norma Euclidean)

• θ adalah sudut antara kedua vektor.

• cos θ adalah kesamaan kosinus antara kedua vektor.

*Menginterpretasikan kemiripan vektor intrinsik *sebagai semakin besar nilai intrinsik (semakin besar nilai positif),

• Besarnya dua buah vektor ( |a| dan |b|) adalah besar,

• Besar sudut antara dua buah vektor (θ) kecil dan (cos θ (mendekati 1))

Ini berarti bahwa kedua vektor menunjuk ke arah yang sama, dan semakin besar magnitudo, semakin mirip keduanya.

Menghitung besaran (norm) sebuah vektor

Vektor definisi norma Euclidean:

Tentang, norma Euclidean |a| didefinisikan sebagai berikut:

Hitung kemiripan antara kueri dan embedding_document

import numpy as np

# Pertanyaan (embedded_query): Saya membutuhkan produk untuk ruangan kantor saya.
np.array(embedded_query) @ np.array(embedded_documents).T

[0.81501292 0.79971248 0.84330415 0.78584163 0.8327097 ]

sorted_idx = (np.array(embedded_query) @ np.array(embedded_documents).T).argsort()[::-1]
sorted_idx

[2 4 0 1 3]

print("[Query] Saya membutuhkan produk untuk ruangan kantor saya.\n====================================")
for i, idx in enumerate(sorted_idx):
    print(f"[{i}] {texts[idx]}")
    print()

[Query] Saya membutuhkan produk untuk ruangan kantor saya
====================================
[0] Kursi Kantor Ergonomis dengan Dukungan Lumbar dan Ketinggian yang Dapat Disesuaikan.

[1] Meja Berdiri Elektrik dengan Tinggi yang Dapat Disetel Memori.

[2] Headphone Bluetooth Nirkabel dengan Pembatalan Kebisingan.

[3] Speaker Bluetooth Tahan Air Portabel dengan Baterai 20 jam.

[4] TV Smart 4K Ultra HD dengan Layanan Streaming dan Kontrol Suara.

HuggingFace Embeddings

intfloat/multilingual-e5-large-instruct

• intfloat/multilingual-e5-large-instruct

• intfloat/multilingual-e5-large

from langchain_huggingface.embeddings import HuggingFaceEmbeddings

model_name = "intfloat/multilingual-e5-large-instruct"
# model_name = "intfloat/multilingual-e5-large"

hf_embeddings = HuggingFaceEmbeddings(
    model_name=model_name,
    model_kwargs={"device": "cuda"},  # cuda, cpu
    encode_kwargs={"normalize_embeddings": True},
)

%time
# Document
embedded_documents1 = hf_embeddings.embed_documents(texts)

Time taken: 1.9415 seconds

print(f"Model: \t\t{model_name}")
print(f"Dimension: \t{len(embedded_documents[0])}")

Model:          intfloat/multilingual-e5-large-instruct
Dimension:      1024

from langchain_huggingface import HuggingFaceEmbeddings

model_name = "BAAI/bge-m3"
model_kwargs = {"device": "cuda"}
encode_kwargs = {"normalize_embeddings": True}
hf_embeddings = HuggingFaceEmbeddings(
    model_name=model_name, model_kwargs=model_kwargs, encode_kwargs=encode_kwargs
)

%time
# Document
embedded_documents = hf_embeddings.embed_documents(texts)

Time taken: 1.9415 seconds

print(f"Model: \t\t{model_name}")
print(f"Dimension: \t{len(embedded_documents[0])}")

Model:          BAAI/bge-m3
Dimension:      1024

Cara menggunakan FlagEmbedding

Referens - FlagEmbedding - BGE-M3 Usage

Dengan menggabungkan tiga pendekatan yang ditawarkan oleh FlagEmbedding, Anda dapat membangun sistem pencarian yang lebih kuat.

Dense Vector: dibangun di atas kemampuan multibahasa dan multitasking BGE-M3 Penyematan jarang dengan bobot leksikal untuk pencocokan kata yang akurat Pendekatan multi-vektor ColBERT untuk pencocokan kontekstual berbutir halus.

# Menginstal FlagEmbedding
!pip install -qU FlagEmbedding

from FlagEmbedding import BGEM3FlagModel

model_name = "BAAI/bge-m3"
bge_embeddings = BGEM3FlagModel(
    model_name, use_fp16=True
)  # Mengatur use_fp16 ke True akan mempercepat proses perhitungan dengan sedikit penurunan kinerja.

bge_embedded = bge_embeddings.encode(
    texts,
    batch_size=12,
    max_length=8192,  # Jika panjang sebesar ini tidak diperlukan, Anda dapat mengatur nilai yang lebih kecil untuk mempercepat proses encoding.
)["dense_vecs"]

bge_embedded.shape

(5, 1024)

print(f"Model: \t\t{model_name}")
print(f"Dimension: \t{len(embedded_documents[0])}")

Model:          BAAI/bge-m3
Dimension:      1024

from FlagEmbedding import BGEM3FlagModel

bge_flagmodel = BGEM3FlagModel(
    "BAAI/bge-m3", use_fp16=True
)  # Mengatur use_fp16 ke True akan mempercepat proses perhitungan dengan sedikit penurunan kinerja.
bge_encoded = bge_flagmodel.encode(texts, return_dense=True)

# Menampilkan hasil (baris, kolom)
bge_encoded["dense_vecs"].shape

(5, 1024)

Sparse Embdedding (Lexical Weight)

Sparse embedding adalah metode embedding yang menggunakan vektor berdimensi tinggi di mana sebagian besar nilai dalam vektor tersebut adalah nol. Metode bobot leksikal memperhitungkan pentingnya kata-kata untuk membuat penyematan.

Cara kerjanya 1. Hitung bobot leksikal untuk setiap kata. Hal ini dapat dilakukan dengan menggunakan metode seperti TF-IDF atau BM25. 2. Untuk setiap kata dalam dokumen atau kueri, tetapkan nilai pada dimensi yang sesuai dari vektor jarang menggunakan bobot leksikal kata tersebut. 3. Hasilnya adalah representasi vektor dimensi tinggi dari dokumen atau kueri dengan sebagian besar nilai adalah nol.

Keuntungan - Dapat secara langsung mencerminkan pentingnya sebuah kata. - Dapat secara akurat mencocokkan kata atau frasa tertentu. - Komputasi relatif cepat.

bge_flagmodel = BGEM3FlagModel(
    "BAAI/bge-m3", use_fp16=True
)  # Mengatur use_fp16 ke True akan mempercepat proses perhitungan dengan sedikit penurunan kinerja.
bge_encoded = bge_flagmodel.encode(texts, return_sparse=True)

lexical_scores1 = bge_flagmodel.compute_lexical_matching_score(
    bge_encoded["lexical_weights"][0], bge_encoded["lexical_weights"][0]
)
lexical_scores2 = bge_flagmodel.compute_lexical_matching_score(
    bge_encoded["lexical_weights"][0], bge_encoded["lexical_weights"][1]
)
# 0 <-> 0
print(lexical_scores1)
# 0 <-> 1
print(lexical_scores2)

0.2894423007965088
0.07880592346191406

Multi-Vector (ColBERT)

Contextualised Late Interaction over BERT (ColBERT) adalah metode yang efisien untuk pencarian dokumen. Metode ini menggunakan pendekatan multi-vektor, di mana dokumen dan kueri diwakili oleh beberapa vektor.

Bagaimana cara kerjanya

1. Vektor terpisah dibuat untuk setiap token dalam dokumen, yaitu, dokumen diwakili oleh beberapa vektor.

2. Kueri juga membuat vektor terpisah untuk setiap token.

3. Saat mencari, kami menghitung kesamaan antara setiap vektor token dalam kueri dan semua vektor token dalam dokumen.

4. Kemiripan ini digabungkan untuk menghitung skor pencarian akhir.

Keuntungan - Pencocokan tingkat token berbutir halus dimungkinkan. - Dapat menghasilkan sematan yang peka terhadap konteks. - Bekerja dengan baik untuk dokumen yang panjang.

bge_flagmodel = BGEM3FlagModel(
    "BAAI/bge-m3", use_fp16=True
)  # Mengatur use_fp16 ke True akan mempercepat proses perhitungan dengan sedikit penurunan kinerja.
bge_encoded = bge_flagmodel.encode(texts, return_colbert_vecs=True)

colbert_scores1 = bge_flagmodel.colbert_score(
    bge_encoded["colbert_vecs"][0], bge_encoded["colbert_vecs"][0]
)
colbert_scores2 = bge_flagmodel.colbert_score(
    bge_encoded["colbert_vecs"][0], bge_encoded["colbert_vecs"][1]
)
# 0 <-> 0
print(colbert_scores1)
# 0 <-> 1
print(colbert_scores2)

tensor(1.)
tensor(0.5276)