Initializes the StaticEmbedding model given a tokenizer. The model is a simple embedding bag model that takes the mean of trained per

Initializes the WordWeights class. Args: vocab (List[str]): Vocabulary of the tokenizer. word_weights (Dict[

A special data loader to be used with MultipleNegativesRankingLoss. The data loader ensures that there are no duplicate sentences wit

Parallel sentences dataset reader to train student model given a teacher model Args: student_model (SentenceTransformer)

Creates a LabelSampler for a SentenceLabelDataset. Args: examples (List[InputExample]): A list of InputExamples.

This loss is a combination of :class:`GISTEmbedLoss` and :class:`CachedMultipleNegativesRankingLoss`. Typically, :class:`MultipleNega

The AdaptiveLayerLoss can be seen as a loss *modifier* that allows you to use other loss functions at non-final layers of the Sentenc

The Matryoshka2dLoss can be seen as a loss *modifier* that combines the :class:`AdaptiveLayerLoss` and the :class:`MatryoshkaLoss`. T

r""" This loss expects as input pairs of damaged inputs and the corresponding original ones. During training, the decoder reconstructs

The MatryoshkaLoss can be seen as a loss *modifier* that allows you to use other loss functions at various different embedding dimens

.. warning:: This class has been merged into :class:`~sentence_transformers.sentence_transformer.losses.CachedMultipleNegativesR

Computes an embedding-distillation loss between the student model's embeddings and pre-computed teacher embeddings (passed as labels)

Computes the MSE loss between the student's embedding and a pre-computed target embedding (passed as a label). Used to extend embeddi

BatchSemiHardTripletLoss takes a batch with (label, input) pairs and computes the loss for all possible, valid triplets, i.e., anchor

.. warning:: This class has been merged into :class:`~sentence_transformers.sentence_transformer.losses.MultipleNegativesRanking

Given a dataset of (anchor, positive) pairs, (anchor, positive, negative) triplets, or (anchor, positive, negative_1, ..., negative_n)

This class implements triplet loss. Given a triplet of (anchor, positive, negative), the loss minimizes the distance between anchor a

This Online Contrastive loss is similar to :class:`ConstrativeLoss`, but it selects hard positive (positives that are far apart) and

This loss is used to train a SentenceTransformer model using the GISTEmbed algorithm. It takes a model and a guide model as input, an

Boosted version of :class:`MultipleNegativesRankingLoss` (https://huggingface.co/papers/1705.00652) by GradCache (https://huggingface.co/pape

BatchHardSoftMarginTripletLoss takes a batch with (input, label) pairs and computes the loss for all possible, valid triplets, i.e.,

This class implements CoSENT (Consistent SENTence embedding) loss. It expects that each of the inputs consists of a pair of inputs (e

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

Contrastive loss. Expects as input two texts and a label of either 0 or 1. If the label == 1, then the distance between the two embed

Given a large batch (like 500 or more examples) of (anchor_i, positive_i) pairs, find for each pair in the batch the hardest negative

Compute the MSE loss between the predicted margin ``sim(Query, Pos) - sim(Query, Neg)`` and the gold margin ``gold_sim(Query, Pos) -

Global Orthogonal Regularization (GOR) Loss that encourages embeddings to be well-distributed in the embedding space by penalizing hi

This loss was used in our SBERT publication (https://huggingface.co/papers/1908.10084) to train the SentenceTransformer model on NLI

CosineSimilarityLoss expects that the inputs consist of two inputs (e.g. texts) and a float label. It computes the vectors ``u = mode

Compute the KL divergence loss between probability distributions derived from student and teacher models' similarity scores. By defau

BatchAllTripletLoss takes a batch with (input, label) pairs and computes the loss for all possible, valid triplets, i.e., anchor and

This class implements AnglE (Angle Optimized) loss. This is a modification of :class:`CoSENTLoss`, designed to address the following

BatchHardTripletLoss takes a batch with (input, label) pairs and computes the loss for all possible, valid triplets, i.e., anchor and

Constructs an evaluator for the given dataset Args: dataloader (DataLoader): the data for the evaluation

Creates one InputExample with the given texts, guid and label Args: guid: id for the example texts: the text

This loss function implements the ListMLE learning to rank algorithm, which uses a list-wise approach based on maximum likelihood est

Computes the MSE loss between the computed query-document score and a target query-document score. This loss is used to distill a cro