MCPcopy Create free account

hub / github.com/huggingface/sentence-transformers / types & classes

Types & classes516 in github.com/huggingface/sentence-transformers

↓ 258 callersClassSentenceTransformer
Loads or creates a SentenceTransformer model that can be used to map text and other inputs to dense embeddings. Args: model_name_or_
sentence_transformers/sentence_transformer/model.py:43
↓ 107 callersClassTransformer
Hugging Face AutoModel wrapper that handles loading, preprocessing, and inference. Loads the appropriate model class (e.g. BERT, RoBERTa, CLIP, W
sentence_transformers/base/modules/transformer.py:688
↓ 106 callersClassMultiVectorEncoder
Loads or creates a multi-vector / late-interaction (ColBERT-style) embedding model. Unlike :class:`~sentence_transformers.sentence_transform
sentence_transformers/multi_vector_encoder/model.py:74
↓ 104 callersClassSentenceTransformerTrainer
SentenceTransformerTrainer is a simple but feature-complete training and eval loop for PyTorch based on the 🤗 Transformers :class:`~transform
sentence_transformers/sentence_transformer/trainer.py:36
↓ 101 callersClassSentenceTransformerTrainingArguments
r""" SentenceTransformerTrainingArguments extends :class:`~sentence_transformers.base.training_args.BaseTrainingArguments` with additional arg
sentence_transformers/sentence_transformer/training_args.py:10
↓ 100 callersClassHierarchicalTokenPooling
Ward-linkage hierarchical clustering on cosine similarity. Excludes the first ``num_protected_tokens`` from clustering (typically the ``[CLS]``),
sentence_transformers/multi_vector_encoder/modules/token_pooling.py:279
↓ 99 callersClassCrossEncoder
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
sentence_transformers/cross_encoder/model.py:46
↓ 68 callersClassSparseEncoder
Loads or creates a SparseEncoder model that can be used to map text to sparse embeddings. Args: model_name_or_path (str, optional):
sentence_transformers/sparse_encoder/model.py:34
↓ 67 callersClassInputFormatter
Handles input parsing, modality detection, and message format conversion. This class manages the complete input preprocessing pipeline: 1. Pa
sentence_transformers/base/modality.py:264
↓ 66 callersClassPooling
Performs pooling on token embeddings to produce fixed-size sentence embeddings. Generates a fixed-size sentence embedding from variable-length to
sentence_transformers/sentence_transformer/modules/pooling.py:70
↓ 63 callersClassDense
Applies a linear transformation with an optional activation function. Passes the embedding through a feed-forward layer (``nn.Linear`` + activati
sentence_transformers/base/modules/dense.py:22
↓ 57 callersClassRouter
sentence_transformers/base/modules/router.py:30
↓ 55 callersClassMultipleNegativesRankingLoss
sentence_transformers/cross_encoder/losses/multiple_negatives_ranking.py:12
↓ 48 callersClassEmbeddingSimilarityEvaluator
Evaluate a model based on the similarity of the embeddings by calculating the Spearman and Pearson rank correlation in comparison to the gold
sentence_transformers/sentence_transformer/evaluation/embedding_similarity.py:27
↓ 38 callersClassCachedMultipleNegativesRankingLoss
sentence_transformers/cross_encoder/losses/cached_multiple_negatives_ranking.py:18
↓ 38 callersClassCrossEncoderTrainer
CrossEncoderTrainer is a simple but feature-complete training and eval loop for PyTorch based on the 🤗 Transformers :class:`~transformers.Tra
sentence_transformers/cross_encoder/trainer.py:34
↓ 34 callersClassCrossEncoderTrainingArguments
r""" CrossEncoderTrainingArguments extends :class:`~sentence_transformers.base.training_args.BaseTrainingArguments` with additional arguments
sentence_transformers/cross_encoder/training_args.py:9
↓ 30 callersClassNormalize
L2-normalizes the embeddings under one of the feature keys to have unit length. By default operates on the pooled ``sentence_embedding`` produced
sentence_transformers/base/modules/normalize.py:14
↓ 26 callersClassMatryoshkaLoss
sentence_transformers/sentence_transformer/losses/matryoshka.py:116
↓ 25 callersClassCosineSimilarityLoss
sentence_transformers/sentence_transformer/losses/cosine_similarity.py:14
↓ 22 callersClassSequentialEvaluator
This evaluator allows that multiple sub-evaluators are passed. When the model is evaluated, the data is passed sequentially to all sub-evalua
sentence_transformers/base/evaluation/sequential.py:12
↓ 21 callersClassSparseEncoderTrainer
SparseEncoderTrainer is a simple but feature-complete training and eval loop for PyTorch based on the SentenceTransformerTrainer that based o
sentence_transformers/sparse_encoder/trainer.py:35
↓ 21 callersClass_PassthroughModel
Stub model that returns the ``token_embeddings`` already placed in the feature dict. The losses call ``self.model(sf, task=...)["token_embeddings
tests/multi_vector_encoder/losses/test_misc.py:30
↓ 20 callersClassCrossEncoderNanoBEIREvaluator
This class evaluates a CrossEncoder model on the NanoBEIR collection of Information Retrieval datasets. The collection is a set of datasets
sentence_transformers/cross_encoder/evaluation/nano_beir.py:53
↓ 20 callersClassSparseEncoderTrainingArguments
r""" SparseEncoderTrainingArguments extends :class:`~sentence_transformers.base.training_args.BaseTrainingArguments` with additional arguments
sentence_transformers/sparse_encoder/training_args.py:9
↓ 19 callersClassBinaryCrossEntropyLoss
sentence_transformers/cross_encoder/losses/binary_cross_entropy.py:9
↓ 19 callersClassInputExample
Structure for one input example with texts, the label and a unique id
sentence_transformers/sentence_transformer/readers/input_example.py:14
↓ 19 callersClassSparseMultipleNegativesRankingLoss
sentence_transformers/sparse_encoder/losses/sparse_multiple_negatives_ranking.py:13
↓ 18 callersClassCrossEncoderRerankingEvaluator
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
sentence_transformers/cross_encoder/evaluation/reranking.py:19
↓ 18 callersClassEmbedDistillLoss
sentence_transformers/sentence_transformer/losses/embed_distill.py:16
↓ 18 callersClassSpladeLoss
sentence_transformers/sparse_encoder/losses/splade.py:16
↓ 17 callersClassGroupByLabelBatchSampler
Batch sampler that groups samples by label for in-batch triplet mining. Samples are shuffled within each label, then interleaved in round-ro
sentence_transformers/base/sampler.py:233
↓ 17 callersClassNoDuplicatesBatchSampler
sentence_transformers/base/sampler.py:412
↓ 17 callersClassTokenizer
tests/sentence_transformer/losses/test_cached_gist_embed.py:94
↓ 16 callersClassMultiVectorMask
Module that overwrites ``features["attention_mask"]`` with the per-row *scoring* mask for late-interaction (ColBERT-style) models. Place this
sentence_transformers/multi_vector_encoder/modules/multi_vector_mask.py:18
↓ 16 callersClassNanoBEIREvaluator
This class evaluates the performance of a SentenceTransformer Model on the NanoBEIR collection of Information Retrieval datasets. The NanoBE
sentence_transformers/sentence_transformer/evaluation/nano_beir.py:57
↓ 15 callersClassInformationRetrievalEvaluator
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
sentence_transformers/sentence_transformer/evaluation/information_retrieval.py:24
↓ 14 callersClassFakeProcessor
Minimal stand-in exposing the two attributes the pair-role probe touches.
tests/base/test_modality.py:1571
↓ 14 callersClassLambdaTokenPooling
User-supplied pool function applied per-sample. Cannot be baked into a saved checkpoint (a Python callable isn't serializable), and will not
sentence_transformers/multi_vector_encoder/modules/token_pooling.py:597
↓ 14 callersClassMSELoss
sentence_transformers/cross_encoder/losses/mse.py:9
↓ 14 callersClassMultiVectorEncoderTrainer
Trainer for :class:`~sentence_transformers.multi_vector_encoder.model.MultiVectorEncoder` (multi-vector / ColBERT-style) models. Inherits all fun
sentence_transformers/multi_vector_encoder/trainer.py:36
↓ 14 callersClassMultiVectorEncoderTrainingArguments
Training arguments for :class:`~sentence_transformers.multi_vector_encoder.model.MultiVectorEncoder` training. Inherits all fields from :class:`~
sentence_transformers/multi_vector_encoder/training_args.py:10
↓ 14 callersClassSparseEncoderModelCardData
A dataclass storing data used in the model card. Args: language (`Optional[Union[str, List[str]]]`): The model language, either a string
sentence_transformers/sparse_encoder/model_card.py:25
↓ 14 callersClassWhitespaceTokenizer
Simple and fast white-space tokenizer. Splits sentence based on white spaces. Punctuation are stripped from tokens.
sentence_transformers/sentence_transformer/modules/tokenizer/whitespace.py:12
↓ 14 callersClass_FakeLoss
Minimal stand-in for a loss object in compute_dataset_metrics calls.
tests/base/test_model_card.py:70
↓ 13 callersClassMultiVectorEncoderModelCardData
A dataclass storing data used in the model card for :class:`~sentence_transformers.multi_vector_encoder.model.MultiVectorEncoder` models. Args:
sentence_transformers/multi_vector_encoder/model_card.py:24
↓ 13 callersClassMultiVectorNanoBEIREvaluator
Evaluates a :class:`~sentence_transformers.multi_vector_encoder.model.MultiVectorEncoder` model on the `NanoBEIR collection <https://huggingface.c
sentence_transformers/multi_vector_encoder/evaluation/nano_beir.py:16
↓ 13 callersClassSentenceTransformerModelCardData
A dataclass storing data used in the model card. Args: language (`Optional[Union[str, List[str]]]`): The model language, either a string
sentence_transformers/sentence_transformer/model_card.py:22
↓ 13 callersClassSoftmaxLoss
sentence_transformers/sentence_transformer/losses/softmax.py:19
↓ 12 callersClassCrossEncoderModelCardData
A dataclass storing data used in the model card. Args: language (`Optional[Union[str, List[str]]]`): The model language, either a string
sentence_transformers/cross_encoder/model_card.py:38
↓ 12 callersClassMultiVectorInformationRetrievalEvaluator
Evaluates a :class:`~sentence_transformers.multi_vector_encoder.model.MultiVectorEncoder` model on an information-retrieval (IR) task. For each qu
sentence_transformers/multi_vector_encoder/evaluation/information_retrieval.py:28
↓ 12 callersClassReciprocalRankFusionEvaluator
This class evaluates a hybrid search approach using Reciprocal Rank Fusion (RRF). Given a query and two separate ranked lists of documents f
sentence_transformers/sparse_encoder/evaluation/reciprocal_rank_fusion.py:17
↓ 11 callersClassAdaptiveLayerLoss
sentence_transformers/sentence_transformer/losses/adaptive_layer.py:84
↓ 11 callersClassMegaBatchMarginLoss
sentence_transformers/sentence_transformer/losses/mega_batch_margin.py:20
↓ 11 callersClassMultiVectorDistillationEvaluator
Distillation evaluator for :class:`~sentence_transformers.multi_vector_encoder.model.MultiVectorEncoder` models. Two data shapes are supported:
sentence_transformers/multi_vector_encoder/evaluation/distillation.py:27
↓ 11 callersClassSparseAutoEncoder
This module implements the Sparse AutoEncoder architecture based on the paper: Beyond Matryoshka: Revisiting Sparse Coding for Adaptive Repre
sentence_transformers/sparse_encoder/modules/sparse_auto_encoder.py:34
↓ 11 callersClassSparseNanoBEIREvaluator
This evaluator extends :class:`~sentence_transformers.sentence_transformer.evaluation.NanoBEIREvaluator` but is specifically designed for sparse
sentence_transformers/sparse_encoder/evaluation/sparse_nano_beir.py:28
↓ 11 callersClassStaticEmbedding
sentence_transformers/sentence_transformer/modules/static_embedding.py:28
↓ 11 callersClass_MockVideoDecoder
Minimal mock for ``torchcodec.decoders.VideoDecoder``. When ``fail_batch=True``, :meth:`get_frames_at` always raises. When ``fail_single=True
tests/base/test_model_card.py:1063
↓ 11 callersClass_MockVideoMetadata
Minimal stand-in for ``torchcodec`` video metadata.
tests/base/test_model_card.py:1043
↓ 10 callersClassControlledNegativeScoreModel
Deterministic model whose anchor-positive score is negative, with a candidate negative that is *more* similar to the anchor than the positive (see
tests/util/test_hard_negatives.py:1891
↓ 10 callersClassDenoisingAutoEncoderLoss
sentence_transformers/sentence_transformer/losses/denoising_auto_encoder.py:37
↓ 10 callersClassParaphraseMiningEvaluator
Given a large set of sentences, this evaluator performs paraphrase (duplicate) mining and identifies the pairs with the highest similarity. I
sentence_transformers/sentence_transformer/evaluation/paraphrase_mining.py:18
↓ 10 callersClassWordEmbeddings
sentence_transformers/sentence_transformer/modules/word_embeddings.py:27
↓ 10 callersClass_PassthroughModel
tests/multi_vector_encoder/losses/test_token_pooling.py:19
↓ 9 callersClassCoSENTLoss
sentence_transformers/sentence_transformer/losses/cosent.py:14
↓ 9 callersClassTaskTypesTrackingModuleDict
tests/base/modules/test_router.py:96
↓ 9 callersClass_ScoreModel
tests/cross_encoder/losses/test_misc.py:99
↓ 8 callersClassDistillKLDivLoss
sentence_transformers/sentence_transformer/losses/distill_kl_div.py:19
↓ 8 callersClassMockModuleWithMaxLength
tests/base/modules/test_router.py:70
↓ 8 callersClassRoundRobinBatchSampler
Batch sampler that yields batches in a round-robin fashion from multiple batch samplers, until one is exhausted. With this sampler, it's unli
sentence_transformers/base/sampler.py:729
↓ 8 callersClassSpladePooling
SPLADE Pooling module for creating the sparse embeddings. This module implements the SPLADE pooling mechanism that: 1. Takes token logi
sentence_transformers/sparse_encoder/modules/splade_pooling.py:14
↓ 8 callersClass_PassthroughModel
tests/multi_vector_encoder/losses/test_matryoshka.py:14
↓ 7 callersClassMockModule
tests/base/modules/test_router.py:31
↓ 7 callersClassMultiVectorMultipleNegativesRankingLoss
In-batch negatives contrastive loss for :class:`~sentence_transformers.multi_vector_encoder.model.MultiVectorEncoder` models. For each query in t
sentence_transformers/multi_vector_encoder/losses/multiple_negatives_ranking.py:22
↓ 7 callersClassRerankingEvaluator
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
sentence_transformers/sentence_transformer/evaluation/reranking.py:26
↓ 7 callersClassTripletEvaluator
Evaluate a model based on a triplet: (sentence, positive_example, negative_example). Checks if ``similarity(sentence, positive_example) > sim
sentence_transformers/sentence_transformer/evaluation/triplet.py:28
↓ 6 callersClassCachedGISTEmbedLoss
sentence_transformers/sentence_transformer/losses/cached_gist_embed.py:25
↓ 6 callersClassCachedMultiVectorMultipleNegativesRankingLoss
A GradCache version of :class:`MultiVectorMultipleNegativesRankingLoss`. Enables much larger effective batch sizes than the non-cached loss at th
sentence_transformers/multi_vector_encoder/losses/cached_multiple_negatives_ranking.py:31
↓ 6 callersClassGISTEmbedLoss
sentence_transformers/sentence_transformer/losses/gist_embed.py:16
↓ 6 callersClassRandContext
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
sentence_transformers/base/losses/gradcache.py:33
↓ 6 callersClassSimilarityFunction
Enum class for supported similarity functions. The following functions are supported: - ``SimilarityFunction.COSINE`` (``"cosine"``): Cosine
sentence_transformers/util/similarity.py:854
↓ 6 callersClassTranslationEvaluator
Given two sets of sentences in different languages, e.g. (en_1, en_2, en_3...) and (fr_1, fr_2, fr_3, ...), and assuming that fr_i is the tra
sentence_transformers/sentence_transformer/evaluation/translation.py:22
↓ 6 callersClass_EchoModel
tests/sentence_transformer/losses/test_contrastive.py:15
↓ 5 callersClassBatchAllTripletLoss
sentence_transformers/sentence_transformer/losses/batch_all_triplet.py:13
↓ 5 callersClassBinaryClassificationEvaluator
Evaluate a model based on the similarity of the embeddings by calculating the accuracy of identifying similar and dissimilar sentences. T
sentence_transformers/sentence_transformer/evaluation/binary_classification.py:27
↓ 5 callersClassBoW
Implements a Bag-of-Words (BoW) model to derive sentence embeddings. A weighting can be added to allow the generation of tf-idf vectors. The outp
sentence_transformers/sentence_transformer/modules/bow.py:16
↓ 5 callersClassCachedSpladeLoss
sentence_transformers/sparse_encoder/losses/cached_splade.py:35
↓ 5 callersClassContrastiveTensionLoss
This loss expects only single inputs, without any labels. Positive and negative pairs are automatically created via random sampling, such tha
sentence_transformers/sentence_transformer/losses/contrastive_tension.py:17
↓ 5 callersClassCrossEncoderCorrelationEvaluator
This evaluator can be used with the CrossEncoder class. Given sentence pairs and continuous scores, it computes the Pearson & Spearman correl
sentence_transformers/cross_encoder/evaluation/correlation.py:19
↓ 5 callersClassLambdaLoss
sentence_transformers/cross_encoder/losses/lambda_loss.py:104
↓ 5 callersClassMultiVectorEncoderDataCollator
Data collator for :class:`~sentence_transformers.multi_vector_encoder.model.MultiVectorEncoder` training. Differs from :class:`~sentence_transfor
sentence_transformers/multi_vector_encoder/data_collator.py:9
↓ 5 callersClassMultiVectorTripletEvaluator
Triplet evaluator for :class:`~sentence_transformers.multi_vector_encoder.model.MultiVectorEncoder` models. Given ``(anchor, positive, negative)`
sentence_transformers/multi_vector_encoder/evaluation/triplet.py:21
↓ 5 callersClassSparseEmbeddingSimilarityEvaluator
This evaluator extends :class:`~sentence_transformers.sentence_transformer.evaluation.EmbeddingSimilarityEvaluator` but is specifically designed
sentence_transformers/sparse_encoder/evaluation/sparse_embedding_similarity.py:22
↓ 5 callersClassSparseInformationRetrievalEvaluator
This evaluator extends :class:`~sentence_transformers.sentence_transformer.evaluation.InformationRetrievalEvaluator` but is specifically designed
sentence_transformers/sparse_encoder/evaluation/sparse_information_retrieval.py:24
↓ 5 callersClassXTRScores
Configured, reusable :func:`xtr_scores` callable for use as a loss ``similarity_fct``. Stores ``top_k`` / ``chunk_elements`` so they don't have t
sentence_transformers/multi_vector_encoder/scoring/xtr.py:189
↓ 5 callersClass_LegacyStash
Per-checkpoint values recovered from legacy save formats (PyLate v3 top-level config, Stanford-NLP ColBERT ``artifact.metadata``) that downstream
sentence_transformers/multi_vector_encoder/model.py:53
↓ 5 callersClass_MaxSimScorer
Model similarity callables backed by device-specific MaxSim operations.
sentence_transformers/multi_vector_encoder/scoring/colbert.py:312
↓ 4 callersClassCNN
CNN-layer with multiple kernel-sizes over the word embeddings
sentence_transformers/sentence_transformer/modules/cnn.py:15
↓ 4 callersClassCSRReconstructionLoss
sentence_transformers/sparse_encoder/losses/csr.py:35
next →1–100 of 516, ranked by callers