Loads or creates a SentenceTransformer model that can be used to map text and other inputs to dense embeddings. Args: model_name_or_

Hugging Face AutoModel wrapper that handles loading, preprocessing, and inference. Loads the appropriate model class (e.g. BERT, RoBERTa, CLIP, W

SentenceTransformerTrainer is a simple but feature-complete training and eval loop for PyTorch based on the 🤗 Transformers :class:`~transform

r""" SentenceTransformerTrainingArguments extends :class:`~sentence_transformers.base.training_args.BaseTrainingArguments` with additional arg

Loads or creates a multi-vector / late-interaction (ColBERT-style) embedding model. Unlike :class:`~sentence_transformers.sentence_transform

Loads or creates a CrossEncoder model that takes a sentence pair as input and outputs a score or label. A CrossEncoder does not produce sent

Handles input parsing, modality detection, and message format conversion. This class manages the complete input preprocessing pipeline: 1. Pa

Loads or creates a SparseEncoder model that can be used to map text to sparse embeddings. Args: model_name_or_path (str, optional):

Performs pooling on token embeddings to produce fixed-size sentence embeddings. Generates a fixed-size sentence embedding from variable-length to

Evaluate a model based on the similarity of the embeddings by calculating the Spearman and Pearson rank correlation in comparison to the gold

CrossEncoderTrainer is a simple but feature-complete training and eval loop for PyTorch based on the 🤗 Transformers :class:`~transformers.Tra

Ward-linkage hierarchical clustering on cosine similarity. Keeps the first ``num_protected_tokens`` untouched (typically the ``[CLS]``), clusters

r""" CrossEncoderTrainingArguments extends :class:`~sentence_transformers.base.training_args.BaseTrainingArguments` with additional arguments

Applies a linear transformation with an optional activation function. Passes the embedding through a feed-forward layer (``nn.Linear`` + activati

Stub model that returns the ``token_embeddings`` already placed in the feature dict. The losses call ``self.model(sf, task=...)["token_embeddings

This class evaluates a CrossEncoder model on the NanoBEIR collection of Information Retrieval datasets. The collection is a set of datasets

This evaluator allows that multiple sub-evaluators are passed. When the model is evaluated, the data is passed sequentially to all sub-evalua

SparseEncoderTrainer is a simple but feature-complete training and eval loop for PyTorch based on the SentenceTransformerTrainer that based o

L2-normalizes the embeddings under one of the feature keys to have unit length. By default operates on the pooled ``sentence_embedding`` produced

r""" SparseEncoderTrainingArguments extends :class:`~sentence_transformers.base.training_args.BaseTrainingArguments` with additional arguments

This class evaluates the performance of a SentenceTransformer Model on the NanoBEIR collection of Information Retrieval datasets. The NanoBE

Batch sampler that groups samples by label for in-batch triplet mining. Samples are shuffled within each label, then interleaved in round-ro

Module that overwrites ``features["attention_mask"]`` with the per-row *scoring* mask for late-interaction (ColBERT-style) models. Place this

This class evaluates a CrossEncoder model for the task of re-ranking. Given a query and a list of documents, it computes the score [query, d

Minimal stand-in exposing the two attributes the pair-role probe touches.

A dataclass storing data used in the model card. Args: language (`Optional[Union[str, List[str]]]`): The model language, either a string

Minimal stand-in for a loss object in compute_dataset_metrics calls.

This class evaluates an Information Retrieval (IR) setting. Given a set of queries and a large corpus set. It will retrieve for each query t

A dataclass storing data used in the model card for :class:`~sentence_transformers.multi_vector_encoder.model.MultiVectorEncoder` models. Args:

A dataclass storing data used in the model card. Args: language (`Optional[Union[str, List[str]]]`): The model language, either a string

A dataclass storing data used in the model card. Args: language (`Optional[Union[str, List[str]]]`): The model language, either a string

Trainer for :class:`~sentence_transformers.multi_vector_encoder.model.MultiVectorEncoder` (multi-vector / ColBERT-style) models. Inherits all fun

Training arguments for :class:`~sentence_transformers.multi_vector_encoder.model.MultiVectorEncoder` training. Inherits all fields from :class:`~

Evaluates a :class:`~sentence_transformers.multi_vector_encoder.model.MultiVectorEncoder` model on an information-retrieval (IR) task. For each qu

This evaluator extends :class:`~sentence_transformers.sentence_transformer.evaluation.NanoBEIREvaluator` but is specifically designed for sparse

Minimal mock for ``torchcodec.decoders.VideoDecoder``. When ``fail_batch=True``, :meth:`get_frames_at` always raises. When ``fail_single=True

Minimal stand-in for ``torchcodec`` video metadata.

User-supplied pool function applied per-sample. Cannot be baked into a saved checkpoint (a Python callable isn't serializable), and will not

Structure for one input example with texts, the label and a unique id

Distillation evaluator for :class:`~sentence_transformers.multi_vector_encoder.model.MultiVectorEncoder` models. Two data shapes are supported:

Evaluates a :class:`~sentence_transformers.multi_vector_encoder.model.MultiVectorEncoder` model on the `NanoBEIR collection <https://huggingface.c

SPLADE Pooling module for creating the sparse embeddings. This module implements the SPLADE pooling mechanism that: 1. Takes token logi

In-batch negatives contrastive loss for :class:`~sentence_transformers.multi_vector_encoder.model.MultiVectorEncoder` models. For each query in t

Snapshot the CPU/CUDA/MPS RNG at init and restore it on enter, so the cached second forward replays the first's randomness (e.g. dropout). Ref: ht

Evaluate a model based on a triplet: (sentence, positive_example, negative_example). Checks if ``similarity(sentence, positive_example) > sim

Evaluate a model based on the similarity of the embeddings by calculating the accuracy of identifying similar and dissimilar sentences. T

This evaluator can be used with the CrossEncoder class. Given sentence pairs and continuous scores, it compute the pearson & spearman correla

Data collator for :class:`~sentence_transformers.multi_vector_encoder.model.MultiVectorEncoder` training. Differs from :class:`~sentence_transfor

Triplet evaluator for :class:`~sentence_transformers.multi_vector_encoder.model.MultiVectorEncoder` models. Given ``(anchor, positive, negative)`

This class evaluates a SentenceTransformer model for the task of re-ranking. Given a query and a list of documents, it computes the score [q

Enum class for supported similarity functions. The following functions are supported: - ``SimilarityFunction.COSINE`` (``"cosine"``): Cosine

Simple and fast white-space tokenizer. Splits sentence based on white spaces. Punctuation are stripped from tokens.

Configured, reusable :func:`xtr_scores` callable for use as a loss ``similarity_fct``. Stores ``top_k`` / ``chunk_elements`` so they don't have t

Per-checkpoint values recovered from legacy save formats (PyLate v3 top-level config, Stanford-NLP ColBERT ``artifact.metadata``) that downstream

Implementation of NDCG Loss2++ weighting scheme. It is a hybrid weighting scheme that combines the NDCGLoss2 and LambdaRank schemes. It was s

Given a large set of sentences, this evaluator performs paraphrase (duplicate) mining and identifies the pairs with the highest similarity. I

This class evaluates a hybrid search approach using Reciprocal Rank Fusion (RRF). Given a query and two separate ranked lists of documents f

Batch sampler that yields batches in a round-robin fashion from multiple batch samplers, until one is exhausted. With this sampler, it's unli

This evaluator extends :class:`~sentence_transformers.sentence_transformer.evaluation.EmbeddingSimilarityEvaluator` but is specifically designed

This evaluator extends :class:`~sentence_transformers.sentence_transformer.evaluation.InformationRetrievalEvaluator` but is specifically designed

Records the query vector of every search, and answers each one with the same single hit.

``id -> row position`` lookup backed by sorted numpy arrays. A python dict retains a hash table plus every key object, and rebuilds that table in

Embeds integer ``input_ids`` as one-hot vectors, mirroring how a real model turns padded token batches into embeddings while the attention mask ma

A GradCache version of :class:`MultiVectorMultipleNegativesRankingLoss`. Enables much larger effective batch sizes than the non-cached loss at th

This loss expects only single inputs, without any labels. Positive and negative pairs are automatically created via random sampling, such tha

Deterministic model whose anchor-positive score is negative, with a candidate negative that is *more* similar to the anchor than the positive (see

This sampler is the default batch sampler used in the SentenceTransformer library. It is equivalent to the PyTorch BatchSampler. Args:

Computes the mean squared error (x100) between the computed sentence embedding and some target sentence embedding. The MSE is computed b