Huấn luyện và Tinh chỉnh Mô hình Embedding & Reranker Đa phương thức với Sentence Transformers

Sentence Transformers là một thư viện Python dùng để sử dụng và huấn luyện các mô hình embedding và reranker cho các ứng dụng như tạo truy xuất tăng cường (RAG), tìm kiếm ngữ nghĩa và nhiều ứng dụng khác. Trong bài viết trước, tôi đã giới thiệu các khả năng đa phương thức mới, hướng dẫn cách sử dụng các mô hình embedding và reranker có thể xử lý văn bản, hình ảnh, âm thanh và video. Trong bài viết này, tôi sẽ hướng dẫn bạn cách huấn luyện hoặc tinh chỉnh (finetune) các mô hình đa phương thức này trên dữ liệu của riêng bạn.

Để làm ví dụ thực tế, tôi sẽ hướng dẫn tinh chỉnh mô hình Qwen/Qwen3-VL-Embedding-2B cho bài toán Truy xuất Tài liệu Hình ảnh (Visual Document Retrieval - VDR). Đây là tác vụ tìm kiếm các trang tài liệu liên quan (dưới dạng hình ảnh, giữ nguyên biểu đồ, bảng biểu và bố cục) cho một truy vấn văn bản cho trước. Mô hình kết quả tomaarsen/Qwen3-VL-Embedding-2B-vdr cho thấy hiệu suất tăng lên đáng kể khi được tinh chỉnh trên miền dữ liệu cụ thể. Trên dữ liệu đánh giá của tôi, mô hình tinh chỉnh đạt NDCG@10 là 0,947 so với 0,888 của mô hình gốc, và vượt qua tất cả các mô hình VDR hiện có mà tôi đã thử nghiệm, bao gồm cả những mô hình lớn gấp 4 lần.

Mẹo: Nếu bạn mới làm quen với các mô hình đa phương thức trong Sentence Transformers, tôi khuyên bạn nên đọc bài Multimodal Embedding & Reranker Models with Sentence Transformers trước. Để huấn luyện các mô hình embedding, reranker hoặc sparse embedding chỉ dành cho văn bản, hãy xem phần Tài nguyên bổ sung ở cuối bài.

Mục lục

1. Tại sao cần tinh chỉnh?
2. Các thành phần huấn luyện
3. Mô hình
4. Dataset
   • Dataset Truy xuất Tài liệu Hình ảnh
   • Định dạng Dataset
5. Hàm mất mát (Loss Function)
   • CachedMultipleNegativesRankingLoss
   • MatryoshkaLoss
6. Đối số huấn luyện
7. Bộ đánh giá (Evaluator)
8. Bộ huấn luyện (Trainer)
9. Kết quả
   • Kích thước mô hình vs NDCG@10
   • Chiều Matryoshka vs NDCG@10
10. Huấn luyện mô hình Reranker đa phương thức
11. Tài nguyên bổ sung

Các mô hình embedding đa phương thức tổng quát như Qwen/Qwen3-VL-Embedding-2B được huấn luyện trên dữ liệu đa dạng để hoạt động tốt trên nhiều ngôn ngữ và tác vụ: khớp hình ảnh-văn bản, trả lời câu hỏi trực quan, hiểu tài liệu, v.v. Tuy nhiên, tính tổng quát này có nghĩa là mô hình hiếm khi là lựa chọn tốt nhất cho một tác vụ cụ thể.

Hãy xem xét bài toán Truy xuất Tài liệu Hình ảnh: với một truy vấn văn bản như “Doanh thu quý 3 của công ty là bao nhiêu?”, mô hình phải tìm thấy ảnh chụp màn hình tài liệu liên quan nhất từ một kho lưu trữ hàng nghìn tấm ảnh. Điều này đòi hỏi khả năng hiểu bố cục tài liệu, biểu đồ, bảng biểu và văn bản, vốn là một kỹ năng rất khác với việc khớp hình ảnh đôi giày với mô tả sản phẩm.

Bằng cách tinh chỉnh trên dữ liệu đặc thù của miền, mô hình có thể học được những đặc điểm chuyên biệt này. Trong thử nghiệm của tôi, việc tinh chỉnh đã cải thiện NDCG@10 từ 0,888 lên 0,947, vượt qua mọi mô hình đa phương thức gần đây mà tôi đã thử nghiệm, kể cả những mô hình lớn hơn gấp 4 lần.

Huấn luyện các mô hình Sentence Transformer đa phương thức bao gồm các thành phần tương tự như huấn luyện mô hình chỉ có văn bản:

1. Mô hình (Model): Mô hình đa phương thức cần huấn luyện hoặc tinh chỉnh.
2. Dataset: Dữ liệu dùng để huấn luyện và đánh giá.
3. Hàm mất mát (Loss Function): Hàm định lượng hiệu suất của mô hình và dẫn dắt quá trình tối ưu hóa.
4. Đối số huấn luyện (Training Arguments) (tùy chọn): Các tham số ảnh hưởng đến hiệu suất huấn luyện và theo dõi/gỡ lỗi.
5. Bộ đánh giá (Evaluator) (tùy chọn): Công cụ để đánh giá mô hình trước, trong hoặc sau khi huấn luyện.
6. Bộ huấn luyện (Trainer): Kết hợp mô hình, dataset, hàm mất mát và các thành phần khác để tiến hành huấn luyện.

Luồng huấn luyện đa phương thức sử dụng cùng một SentenceTransformerTrainer như huấn luyện văn bản. Điểm khác biệt chính là dataset của bạn chứa hình ảnh (hoặc các phương thức khác) cùng với văn bản, và bộ xử lý (processor) của mô hình sẽ tự động xử lý tiền xử lý hình ảnh.

Cách phổ biến nhất là tinh chỉnh một mô hình embedding đa phương thức hiện có, hoặc bắt đầu từ một checkpoint của Mô hình Ngôn ngữ - Thị giác (Vision-Language Model - VLM). Module Transformer sẽ tự động phát hiện các phương thức được hỗ trợ từ bộ xử lý của mô hình.

Để tinh chỉnh một mô hình embedding đa phương thức hiện có (ví dụ: mô hình đã có tệp modules.json), bạn có thể truyền processor_kwargs và model_kwargs để kiểm soát tiền xử lý và tải mô hình. processor_kwargs được truyền trực tiếp đến AutoProcessor.from_pretrained(...) (ví dụ: giới hạn độ phân giải hình ảnh: max_pixels cao hơn nghĩa là chất lượng cao hơn nhưng tốn nhiều bộ nhớ hơn), trong khi model_kwargs được truyền đến AutoModel.from_pretrained(...) (ví dụ: độ chính xác, triển khai attention):

from sentence_transformers import SentenceTransformer

model = SentenceTransformer(
    "Qwen/Qwen3-VL-Embedding-2B",
    model_kwargs={"attn_implementation": "flash_attention_2", "torch_dtype": "bfloat16"},
    processor_kwargs={"min_pixels": 28 * 28, "max_pixels": 600 * 600},
)

Bạn cũng có thể bắt đầu từ một checkpoint VLM mới chưa được huấn luyện cho embedding. Sentence Transformers sẽ cố gắng nhận diện kiến trúc, suy luận các phương thức được hỗ trợ và thiết lập phương thức forward và pooling phù hợp.

Trong cả hai trường hợp, module Transformer sẽ kiểm tra bộ xử lý để xác định phương thức khả dụng, và Pooling sẽ được tự động thêm vào nếu cần. Bạn có thể kiểm tra các phương thức được hỗ trợ:

print(model.modalities)
# ['text', 'image', 'video', 'message']

print(model.supports("image"))
# True

Thay vì dùng một backbone VLM duy nhất, bạn có thể kết hợp các encoder riêng biệt cho các phương thức khác nhau bằng module Router. Điều này cho phép bạn kết hợp bất kỳ encoder hiện có nào và điều hướng đầu vào đến encoder phù hợp:

from sentence_transformers import SentenceTransformer
from sentence_transformers.sentence_transformer.modules import Dense, Pooling, Router, Transformer

# Tạo encoder riêng cho từng phương thức
text_encoder = Transformer("sentence-transformers/all-MiniLM-L6-v2")
text_pooling = Pooling(text_encoder.get_embedding_dimension(), pooling_mode="mean")
text_projection = Dense(text_encoder.get_embedding_dimension(), 768)

# SigLIP xuất ra embedding đã pooled trực tiếp, nên không cần module Pooling riêng
image_encoder = Transformer("google/siglip2-base-patch16-224")

# Điều hướng đầu vào dựa trên phương thức
router = Router(
    sub_modules={
        "text": [text_encoder, text_pooling, text_projection],
        "image": [image_encoder],
    },
)

model = SentenceTransformer(modules=[router])

Cảnh báo: Vì các mô hình đa phương thức dựa trên Router sử dụng các encoder riêng cho mỗi phương thức, không gian embedding của chúng ban đầu không đồng nhất. Cần huấn luyện để căn chỉnh các không gian này. Lớp chiếu Dense ở trên giúp ánh xạ embedding từ các encoder khác nhau vào một không gian chung.

Trong ví dụ này, tôi sử dụng dataset tomaarsen/llamaindex-vdr-en-train-preprocessed, một tập con tiếng Anh đã được tiền xử lý từ llamaindex/vdr-multilingual-train. Dataset gốc bao gồm khoảng 500k mẫu truy vấn-hình ảnh đa ngôn ngữ từ các tệp PDF công khai, với các truy vấn được tạo tổng hợp bằng VLM (gemini-1.5-pro và Qwen2-VL-72B). Phiên bản tiền xử lý của tôi lọc ra 53,512 mẫu tiếng Anh và giải quyết 4 trong số 16 mẫu negative cứng dựa trên ID thành hình ảnh chụp màn hình tài liệu thực tế:

from datasets import load_dataset

train_dataset = load_dataset("tomaarsen/llamaindex-vdr-en-train-preprocessed", "train", split="train")
train_dataset = train_dataset.select_columns(["query", "image", "negative_0"])
eval_dataset = load_dataset("tomaarsen/llamaindex-vdr-en-train-preprocessed", "eval", split="train")

Tôi chọn query, image và negative_0 để tạo thành các bộ ba (anchor, positive, hard negative). Việc thêm nhiều negative cứng hơn có thể cải thiện tín hiệu huấn luyện, nhưng mỗi negative thêm vào sẽ làm tăng mức sử dụng bộ nhớ và thời gian huấn luyện.

Tương tự như huấn luyện chỉ văn bản, định dạng dataset phải khớp với hàm mất mát bạn chọn:

1. Nếu hàm mất mất yêu cầu một Label, dataset phải có cột tên là “label” hoặc “score”.
2. Tất cả các cột khác ngoài “label” hoặc “score” được coi là Inputs. Số lượng các cột này phải khớp với số lượng đầu vào hợp lệ của hàm mất mát.

Đối với dataset đa phương thức, đầu vào có thể chứa:

• Văn bản: chuỗi (strings).
• Hình ảnh: ảnh PIL, đường dẫn tệp, URL, hoặc mảng numpy/torch.
• Âm thanh: đường dẫn tệp, mảng numpy/torch, hoặc dict chứa "array" và "sampling_rate".
• Video: đường dẫn tệp, mảng numpy/torch, hoặc dict chứa "array" và "video_metadata".
• Dict đa phương thức: một dict ánh xạ tên phương thức tới giá trị, ví dụ: {"text": ..., "image": ...}.

Bộ collator dữ liệu sẽ tự động gọi model.preprocess(), tự phát hiện phương thức của mỗi đầu vào và áp dụng tiền xử lý phù hợp. Bạn không cần tokenization hay xử lý ảnh thủ công.

Tôi sử dụng CachedMultipleNegativesRankingLoss, một lựa chọn phổ biến cho các tác vụ truy xuất. Nó chấp nhận các cặp (truy vấn, positive) cùng với bất kỳ số lượng cột negative cứng nào. Trong quá trình huấn luyện, hàm này đẩy độ tương đồng giữa truy vấn và mẫu positive lên và đẩy độ tương đồng với mọi mẫu negative xuống. Các mẫu negative đến từ hai nguồn:

1. Hard negatives: các cột negative được cung cấp rõ ràng trong dataset.
2. In-batch negatives: các mẫu positive và negative cứng từ mọi mẫu khác trong cùng một batch.

Batch size càng lớn thì tín hiệu huấn luyện càng mạnh. Biến thể “cached” sử dụng gradient caching để cho phép batch size hiệu dụng lớn ngay cả khi bộ nhớ GPU hạn chế.

Tham số mini_batch_size kiểm soát số lượng mẫu được xử lý cùng lúc trong các lượt forward cached. Với các mô hình đa phương thức lớn, nên đặt giá trị này nhỏ (ví dụ: 1) để tránh lỗi hết bộ nhớ (OOM):

from sentence_transformers.sentence_transformer.losses import CachedMultipleNegativesRankingLoss

loss = CachedMultipleNegativesRankingLoss(model, mini_batch_size=1)

Để tạo ra các embedding hoạt động tốt ở nhiều mức chiều khác nhau, tôi bao bọc hàm mất mát cơ bản bằng MatryoshkaLoss. Điều này huấn luyện mô hình sao cho việc cắt bớt embedding xuống số chiều nhỏ hơn vẫn mang lại hiệu suất tốt:

from sentence_transformers.sentence_transformer.losses import CachedMultipleNegativesRankingLoss, MatryoshkaLoss

loss = CachedMultipleNegativesRankingLoss(model, mini_batch_size=1)
loss = MatryoshkaLoss(model, loss, matryoshka_dims=[2048, 1536, 1024, 512, 256, 128, 64])

Điều này đặc biệt hữu ích cho các mô hình đa phương thức có embedding lớn (ví dụ: 2048 chiều của Qwen3-VL). Khi triển khai, bạn có thể dùng embedding đã cắt (ví dụ: 256 hoặc 128 chiều) để tìm kiếm nhanh hơn với tổn thất chất lượng tối thiểu.

Lớp SentenceTransformerTrainingArguments cho phép kiểm soát các siêu tham số. Dưới đây là cấu hình cho VDR:

from sentence_transformers.sentence_transformer.training_args import SentenceTransformerTrainingArguments, BatchSamplers

run_name = "Qwen3-VL-Embedding-2B-vdr"
args = SentenceTransformerTrainingArguments(
    output_dir=f"models/{run_name}",
    num_train_epochs=1,
    per_device_train_batch_size=64,
    per_device_eval_batch_size=64,
    learning_rate=2e-5,
    warmup_ratio=0.1,
    fp16=False,
    bf16=True,
    batch_sampler=BatchSamplers.NO_DUPLICATES,
    eval_strategy="steps",
    eval_steps=0.1,
    save_strategy="steps",
    save_steps=0.1,
    save_total_limit=2,
    logging_steps=0.05,
    run_name=run_name,
)

Lưu ý cho huấn luyện đa phương thức:

• bf16=True: bfloat16 thường được ưu tiên hơn float16 vì độ ổn định số học tốt hơn.
• batch_sampler=BatchSamplers.NO_DUPLICATES: Đảm bảo không có mẫu trùng lặp trong một batch, giúp các in-batch negatives thực sự khác biệt.
• per_device_train_batch_size=64: Có vẻ lớn cho một VLM 2B, nhưng CachedMultipleNegativesRankingLoss với mini_batch_size=1 sẽ xử lý giới hạn bộ nhớ thông qua gradient caching.

Tôi sử dụng InformationRetrievalEvaluator để theo dõi hiệu suất truy xuất, tính toán các chỉ số như NDCG@10, MAP và Recall@k:

from sentence_transformers.sentence_transformer.evaluation import InformationRetrievalEvaluator

# Xây dựng dữ liệu đánh giá từ eval_dataset
eval_queries = {qid: sample["query"] for qid, sample in enumerate(eval_dataset)}
eval_corpus = {did: sample["image"] for did, sample in enumerate(eval_dataset)}
num_eval = len(eval_dataset)

# Thêm negative cứng vào corpus
negative_columns = ["negative_0", "negative_1", "negative_2", "negative_3"]
for neg_idx, neg_col in enumerate(negative_columns):
    for did, sample in enumerate(eval_dataset):
        eval_corpus[num_eval * (neg_idx + 1) + did] = sample[neg_col]

eval_relevant_docs = {idx: [idx] for idx in range(len(eval_dataset))}

eval_evaluator = InformationRetrievalEvaluator(
    queries=eval_queries,
    corpus=eval_corpus,
    relevant_docs=eval_relevant_docs,
    batch_size=1,
    show_progress_bar=True,
    name="vdr-eval-hard",
)

SentenceTransformerTrainer kết nối mọi thứ lại với nhau. Đây là script huấn luyện đầy đủ:

from datasets import load_dataset
from sentence_transformers import SentenceTransformer
from sentence_transformers.sentence_transformer.evaluation import InformationRetrievalEvaluator
from sentence_transformers.sentence_transformer.losses import CachedMultipleNegativesRankingLoss, MatryoshkaLoss
from sentence_transformers.sentence_transformer.model_card import SentenceTransformerModelCardData
from sentence_transformers.sentence_transformer.trainer import SentenceTransformerTrainer
from sentence_transformers.sentence_transformer.training_args import (
    BatchSamplers,
    SentenceTransformerTrainingArguments,
)

# 1. Tải mô hình để tinh chỉnh
model = SentenceTransformer(
    "Qwen/Qwen3-VL-Embedding-2B",
    model_card_data=SentenceTransformerModelCardData(
        language="en",
        license="apache-2.0",
        model_name="Qwen3-VL-Embedding-2B model trained on Visual Document Retrieval query-document screenshot pairs",
    ),
    model_kwargs={"attn_implementation": "flash_attention_2", "torch_dtype": "bfloat16"},
    processor_kwargs={"min_pixels": 28 * 28, "max_pixels": 600 * 600},
)

# 2. Tải dataset
train_dataset = load_dataset("tomaarsen/llamaindex-vdr-en-train-preprocessed", "train", split="train")
train_dataset = train_dataset.select_columns(["query", "image", "negative_0"])
eval_dataset = load_dataset("tomaarsen/llamaindex-vdr-en-train-preprocessed", "eval", split="train")

# 3. Định nghĩa hàm mất mát
loss = CachedMultipleNegativesRankingLoss(model, mini_batch_size=1)
loss = MatryoshkaLoss(model, loss, matryoshka_dims=[2048, 1536, 1024, 512, 256, 128, 64])

# 4. Đối số huấn luyện
run_name = "Qwen3-VL-Embedding-2B-vdr"
args = SentenceTransformerTrainingArguments(
    output_dir=f"models/{run_name}",
    num_train_epochs=1,
    per_device_train_batch_size=64,
    per_device_eval_batch_size=64,
    learning_rate=2e-5,
    warmup_ratio=0.1,
    fp16=False,
    bf16=True,
    batch_sampler=BatchSamplers.NO_DUPLICATES,
    eval_strategy="steps",
    eval_steps=0.1,
    save_strategy="steps",
    save_steps=0.1,
    save_total_limit=2,
    logging_steps=0.05,
    run_name=run_name,
)

# 5. Tạo bộ đánh giá
eval_queries = {qid: sample["query"] for qid, sample in enumerate(eval_dataset)}
eval_corpus = {did: sample["image"] for did, sample in enumerate(eval_dataset)}
num_eval = len(eval_dataset)
negative_columns = ["negative_0", "negative_1", "negative_2", "negative_3"]
for neg_idx, neg_col in enumerate(negative_columns):
    for did, sample in enumerate(eval_dataset):
        eval_corpus[num_eval * (neg_idx + 1) + did] = sample[neg_col]
eval_relevant_docs = {idx: [idx] for idx in range(len(eval_dataset))}

eval_evaluator = InformationRetrievalEvaluator(
    queries=eval_queries,
    corpus=eval_corpus,
    relevant_docs=eval_relevant_docs,
    batch_size=1,
    show_progress_bar=True,
    name="vdr-eval-hard",
)
eval_evaluator(model)

# 6. Tạo trainer và huấn luyện
trainer = SentenceTransformerTrainer(
    model=model,
    args=args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
    loss=loss,
    evaluator=eval_evaluator,
)
trainer.train()

# 7. Đánh giá tại mỗi chiều Matryoshka
eval_evaluator(model)
for dim in [2048, 1536, 1024, 512, 256, 128, 64]:
    dim_evaluator = InformationRetrievalEvaluator(
        queries=eval_queries,
        corpus=eval_corpus,
        relevant_docs=eval_relevant_docs,
        truncate_dim=dim,
        batch_size=1,
        show_progress_bar=True,
        name=f"vdr-eval-hard-{dim}d",
    )
    dim_evaluator(model)

# 8. Lưu mô hình
model.save_pretrained(f"models/{run_name}/final")

# 9. Đẩy lên Hugging Face Hub
model.push_to_hub("Qwen3-VL-Embedding-2B-vdr")

Sau 1 epoch huấn luyện, mô hình tomaarsen/Qwen3-VL-Embedding-2B-vdr đạt NDCG@10 là 0,947 trên tập đánh giá. Đây là sự cải thiện đáng kể so với mức 0,888 của mô hình gốc Qwen/Qwen3-VL-Embedding-2B và vượt qua tất cả các mô hình VDR hiện có:

Chi tiết NDCG@10 theo mô hình (Top mẫu):

Mô hình 2B tinh chỉnh thậm chí còn vượt qua cả mô hình Qwen3-VL-Embedding 8B, chứng minh sức mạnh của việc tinh chỉnh cho tác vụ cụ thể.

Nhờ huấn luyện Matryoshka, mô hình vẫn giữ được hiệu suất cao khi bị cắt bớt chiều, cho phép bạn đánh đổi giữa kích thước embedding và chất lượng truy xuất:

Ghi chú: Hiệu suất đỉnh đạt được ở 2048 chiều (0,948), nhưng vẫn duy trì trong khoảng 0,3% so với đỉnh cho đến khi giảm xuống 512 chiều (nhỏ hơn 4 lần), và giữ được hơn 92% hiệu suất ngay cả ở 64 chiều (nhỏ hơn 32 lần).

Khoảng cách giữa 1024 và 2048 chiều là rất nhỏ (0,946 so với 0,948), vì vậy tôi đã lưu mô hình với truncate_dim=1024. Điều này giúp giảm một nửa dung lượng lưu trữ so với bản đầy đủ.

Bạn cũng có thể tinh chỉnh các mô hình Cross Encoder (reranker) đa phương thức. Điểm khác biệt chính là sử dụng CrossEncoderTrainer và các hàm mất mát đặc thù cho Cross Encoder.

Ví dụ đơn giản hóa dựa trên script huấn luyện doodles (khớp hình ảnh với chú thích văn bản):

from sentence_transformers.cross_encoder import CrossEncoder
from sentence_transformers.cross_encoder.losses import BinaryCrossEntropyLoss
from sentence_transformers.cross_encoder.modules import LogitScore, Transformer
from sentence_transformers.cross_encoder.trainer import CrossEncoderTrainer
from sentence_transformers.cross_encoder.training_args import CrossEncoderTrainingArguments

# 1. Xây dựng mô hình từ các module
transformer = Transformer(
    "Qwen/Qwen3.5-0.8B",
    transformer_task="any-to-any",
    model_kwargs={"torch_dtype": "bfloat16", "device_map": "auto", "attn_implementation": "flash_attention_2"},
    processing_kwargs={"chat_template": {"add_generation_prompt": True}},
)

# Mở rộng chat template để hỗ trợ vai trò "query" và "document"
transformer.processor.chat_template = transformer.processor.chat_template.replace(
    'message.role == "user"', 'message.role in ["user", "query", "document"]'
)

# LogitScore: score = log(P("1")) - log(P("0"))
score_head = LogitScore(
    true_token_id=transformer.tokenizer.convert_tokens_to_ids("1"),
    false_token_id=transformer.tokenizer.convert_tokens_to_ids("0"),
)

model = CrossEncoder(
    modules=[transformer, score_head],
    num_labels=1,
    prompts={
        "image_to_text": "Given the image, judge whether the text matches it. Respond with 1 if they match, 0 if they don't.",
        "text_to_image": "Given the text, judge whether the image matches it. Respond with 1 if they match, 0 if they don't.",
    },
)

# 2. Định nghĩa hàm mất mát
loss = BinaryCrossEntropyLoss(model)

# 3. Huấn luyện đa dataset với các hướng khác nhau
trainer = CrossEncoderTrainer(
    model=model,
    args=args,
    train_dataset={"image_to_text": train_image_to_text, "text_to_image": train_text_to_image},
    eval_dataset={"image_to_text": eval_image_to_text, "text_to_image": eval_text_to_image},
    loss=loss,
    evaluator=[image_to_text_evaluator, text_to_image_evaluator],
)
trainer.train()

Có nhiều lựa chọn kiến trúc cho reranker đa phương thức, bao gồm:

1. Any-to-Any + LogitScore: Sử dụng LLM đa phương thức để tạo ra một token, sau đó tính log-odds của “1” so với “0”.
2. Feature Extraction + Pooling + Dense: Chỉ sử dụng mô hình cơ sở, trích xuất hidden state của token cuối cùng và chiếu nó thành điểm số qua lớp Dense.

Các bài viết trước

• Multimodal Embedding & Reranker Models with Sentence Transformers: Suy luận đa phương thức.
• Training and Finetuning Embedding Models with Sentence Transformers v3: Huấn luyện mô hình embedding.
• Training and Finetuning Reranker Models with Sentence Transformers v4: Huấn luyện mô hình reranker.
• Training and Finetuning Sparse Embedding Models with Sentence Transformers v5: Huấn luyện mô hình sparse embedding.

Ví dụ huấn luyện

• Visual Document Retrieval: Script dùng trong bài viết này.
• Multimodal Reranker (Any-to-Any): Huấn luyện reranker dùng LogitScore.
• Multimodal Reranker (Feature Extraction): Huấn luyện reranker dùng Pooling + Dense.

Tài liệu

• Tổng quan huấn luyện Sentence Transformer
• Tổng quan hàm mất mát Sentence Transformer
• Tổng quan huấn luyện Cross Encoder
• Tổng quan hàm mất mát Cross Encoder
• Tổng quan về Dataset
• Tham chiếu API

Link bài viết gốc

• Tags:
• Ai
• 16 April 2026
• Huggingface.co