\n
\n \n ![](\"https://sbert.net/_static/hf-logo.svg\")
\n
\n \n Star\n \n \n | \n \n Model Name\n | \n\n \n Performance Sentence Embeddings (14 Datasets)\n \n | \n\n \n Performance Semantic Search (6 Datasets)\n \n | \n\n \n Avg. Performance\n \n | \n\n \n Speed\n \n | \n\n \n Model Size\n \n | \n||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| \n {{ item.name }}\n \n | \n{{ item.sentence_performance > 0 ? item.sentence_performance.toFixed(2) : \"\" }} | \n{{ item.semantic_search > 0 ? item.semantic_search.toFixed(2) : \"\" }} | \n{{ (item.sentence_performance > 0 && item.semantic_search > 0) ? item.avg_performance.toFixed(2) : \"\" }} | \n{{ item.speed }} | \n{{ item.size }} MB | \n||||||||||||||||
\n
| \n
\n BinaryCrossEntropyLoss is a traditional option that remains very challenging to outperform.\n- `(anchor, positive) pairs` without any labels: combined with mine_hard_negatives\n - with output_format=\"labeled-list\", then LambdaLoss is frequently used for learning-to-rank tasks.\n - with output_format=\"labeled-pair\", then BinaryCrossEntropyLoss remains a strong option.\n\n## Custom Loss Functions\n\n```{eval-rst}\nAdvanced users can create and train with their own loss functions. Custom loss functions only have a few requirements:\n\n- They must be a subclass of :class:`torch.nn.Module`.\n- They must have ``model`` as the first argument in the constructor.\n- They must implement a ``forward`` method that accepts ``inputs`` and ``labels``. The former is a nested list of texts in the batch, with each element in the outer list representing a column in the training dataset. You have to combine these texts into pairs that can be 1) tokenized and 2) fed to the model. The latter is an optional (list of) tensor(s) of labels from a ``label``, ``labels``, ``score``, or ``scores`` column in the dataset. The method must return a single loss value or a dictionary of loss components (component names to loss values) that will be summed to produce the final loss value. When returning a dictionary, the individual components will be logged separately in addition to the summed loss, allowing you to monitor the individual components of the loss.\n\nTo get full support with the automatic model card generation, you may also wish to implement:\n\n- a ``get_config_dict`` method that returns a dictionary of loss parameters.\n- a ``citation`` property so your work gets cited in all models that train with the loss.\n\nConsider inspecting existing loss functions to get a feel for how loss functions are commonly implemented.\n```\n"
},
{
"path": "docs/cross_encoder/pretrained_models.md",
"content": "# Pretrained Models\n\n```{eval-rst}\nWe have released various pre-trained Cross Encoder models via our Cross Encoder Hugging Face organization. Additionally, numerous community Cross Encoder models have been publicly released on the Hugging Face Hub.\n\n* **Original models**: `Cross Encoder Hugging Face organization learning_rate\n lr_scheduler_type\n warmup_ratio\n num_train_epochs\n max_steps\n per_device_train_batch_size\n per_device_eval_batch_size\n auto_find_batch_size\n fp16\n bf16\n load_best_model_at_end\n metric_for_best_model\n gradient_accumulation_steps\n gradient_checkpointing\n eval_accumulation_steps\n optim\n dataloader_num_workers\n dataloader_prefetch_factor\n batch_sampler\n multi_dataset_batch_sampler\n learning_rate_mapping\n eval_strategy\n eval_steps\n save_strategy\n save_steps\n save_total_limit\n report_to\n run_name\n log_level\n logging_steps\n push_to_hub\n hub_model_id\n hub_strategy\n hub_private_repo\n model_kwargs will be passed on to OVBaseModel.from_pretrained(). Some notable arguments include:\n\n* ``file_name``: The name of the ONNX file to load. If not specified, will default to ``\"openvino_model.xml\"`` or otherwise ``\"openvino/openvino_model.xml\"``. This argument is useful for specifying optimized or quantized models.\n* ``export``: A boolean flag specifying whether the model will be exported. If not provided, ``export`` will be set to ``True`` if the model repository or directory does not already contain an OpenVINO model.\n\n.. tip::\n\n It's heavily recommended to save the exported model to prevent having to re-export it every time you run your code. You can do this by calling :meth:`model.save_pretrained() sentence1 and sentence2 columns as pairs, with 38.94 ± 13.97 and 38.96 ± 14.05 characters on average, respectively.\n query and answer columns as pairs, with 46.99 ± 10.98 and 619.63 ± 345.30 characters on average, respectively.\n text column: first 100 characters (100.00 ± 0.00 characters) and each sample repeated 4 times (16804.25 ± 10178.26 characters).\n torch-fp32: PyTorch with float32 precision (default).\n torch-fp16: PyTorch with float16 precision, via model_kwargs={\"torch_dtype\": \"float16\"}.\n torch-bf16: PyTorch with bfloat16 precision, via model_kwargs={\"torch_dtype\": \"bfloat16\"}.\n onnx: ONNX with float32 precision, via backend=\"onnx\".\n onnx-O1: ONNX with float32 precision and O1 optimization, via export_optimized_onnx_model(..., optimization_config=\"O1\", ...) and backend=\"onnx\".\n onnx-O2: ONNX with float32 precision and O2 optimization, via export_optimized_onnx_model(..., optimization_config=\"O2\", ...) and backend=\"onnx\".\n onnx-O3: ONNX with float32 precision and O3 optimization, via export_optimized_onnx_model(..., optimization_config=\"O3\", ...) and backend=\"onnx\".\n onnx-O4: ONNX with float16 precision and O4 optimization, via export_optimized_onnx_model(..., optimization_config=\"O4\", ...) and backend=\"onnx\".\n onnx-qint8: ONNX quantized to int8 with \"avx512_vnni\", via export_dynamic_quantized_onnx_model(..., quantization_config=\"avx512_vnni\", ...) and backend=\"onnx\". The different quantization configurations resulted in roughly equivalent speedups.\n openvino: OpenVINO, via backend=\"openvino\".\n openvino-qint8: OpenVINO quantized to int8 via export_static_quantized_openvino_model(..., quantization_config=OVQuantizationConfig(), ...) and backend=\"openvino\".\n ![\"SBERT](\"https://raw.githubusercontent.com/huggingface/sentence-transformers/main/docs/img/SBERT_Siamese_Network.png\")
\n\nFor each sentence pair, we pass sentence A and sentence B through our network which yields the embeddings *u* und *v*. The similarity of these embeddings is computed using cosine similarity and the result is compared to the gold similarity score.\n\nThis allows our network to be fine-tuned to recognize the similarity of sentences.\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.losses.CosineSimilarityLoss\n```\n\n## DenoisingAutoEncoderLoss\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.losses.DenoisingAutoEncoderLoss\n```\n\n## GISTEmbedLoss\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.losses.GISTEmbedLoss\n```\n\n## CachedGISTEmbedLoss\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.losses.CachedGISTEmbedLoss\n```\n\n## GlobalOrthogonalRegularizationLoss\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.losses.GlobalOrthogonalRegularizationLoss\n```\n\n## MSELoss\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.losses.MSELoss\n```\n\n## MarginMSELoss\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.losses.MarginMSELoss\n```\n\n## MatryoshkaLoss\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.losses.MatryoshkaLoss\n```\n\n## Matryoshka2dLoss\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.losses.Matryoshka2dLoss\n```\n\n## AdaptiveLayerLoss\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.losses.AdaptiveLayerLoss\n```\n\n## MegaBatchMarginLoss\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.losses.MegaBatchMarginLoss\n```\n\n## MultipleNegativesRankingLoss\n\n*MultipleNegativesRankingLoss* is a great loss function if you only have positive pairs, for example, only pairs of similar texts like pairs of paraphrases, pairs of duplicate questions, pairs of (query, response), or pairs of (source_language, target_language).\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.losses.MultipleNegativesRankingLoss\n```\n\n## CachedMultipleNegativesRankingLoss\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.losses.CachedMultipleNegativesRankingLoss\n```\n\n## MultipleNegativesSymmetricRankingLoss\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.losses.MultipleNegativesSymmetricRankingLoss\n```\n\n## CachedMultipleNegativesSymmetricRankingLoss\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.losses.CachedMultipleNegativesSymmetricRankingLoss\n```\n\n## SoftmaxLoss\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.losses.SoftmaxLoss\n```\n\n## TripletLoss\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.losses.TripletLoss\n```\n\n## DistillKLDivLoss\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.losses.DistillKLDivLoss\n```\n"
},
{
"path": "docs/package_reference/sentence_transformer/models.md",
"content": "# Modules\n\n`sentence_transformers.models` defines different building blocks, a.k.a. Modules, that can be used to create SentenceTransformer models from scratch. For more details, see [Creating Custom Models](../../sentence_transformer/usage/custom_models.rst).\n\n## Main Modules\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.models.Transformer\n.. autoclass:: sentence_transformers.models.Pooling\n.. autoclass:: sentence_transformers.models.Dense\n.. autoclass:: sentence_transformers.models.Normalize\n.. autoclass:: sentence_transformers.models.Router\n :members: for_query_document\n.. autoclass:: sentence_transformers.models.StaticEmbedding\n :members: from_model2vec, from_distillation\n```\n\n## Further Modules\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.models.BoW\n.. autoclass:: sentence_transformers.models.CNN\n.. autoclass:: sentence_transformers.models.LSTM\n.. autoclass:: sentence_transformers.models.WeightedLayerPooling\n.. autoclass:: sentence_transformers.models.WordEmbeddings\n.. autoclass:: sentence_transformers.models.WordWeights\n```\n\n## Base Modules\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.models.Module\n :members: config_file_name, config_keys, save_in_root, forward, get_config_dict, load, load_config, load_file_path, load_dir_path, load_torch_weights, save, save_config, save_torch_weights\n.. autoclass:: sentence_transformers.models.InputModule\n :members: save_in_root, tokenizer, tokenize, save_tokenizer\n```\n"
},
{
"path": "docs/package_reference/sentence_transformer/quantization.md",
"content": "# quantization\n\n`sentence_transformers.quantization` defines different helpful functions to perform embedding quantization.\n\n```{eval-rst}\n.. note::\n `Embedding Quantization <../../../examples/sentence_transformer/applications/embedding-quantization/README.html>`_ differs from model quantization. The former shrinks the size of embeddings such that semantic search/retrieval is faster and requires less memory and disk space. The latter refers to lowering the precision of the model weights to speed up inference. This page only shows documentation for the former.\n```\n\n```{eval-rst}\n.. automodule:: sentence_transformers.quantization\n :members: quantize_embeddings, semantic_search_faiss, semantic_search_usearch\n```\n"
},
{
"path": "docs/package_reference/sentence_transformer/sampler.md",
"content": "# Samplers\n\n## BatchSamplers\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.training_args.BatchSamplers\n :members:\n```\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.sampler.DefaultBatchSampler\n :members:\n```\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.sampler.NoDuplicatesBatchSampler\n :members:\n```\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.sampler.GroupByLabelBatchSampler\n :members:\n```\n\n## MultiDatasetBatchSamplers\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.training_args.MultiDatasetBatchSamplers\n :members:\n```\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.sampler.MultiDatasetDefaultBatchSampler\n :members:\n```\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.sampler.RoundRobinBatchSampler\n :members:\n```\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.sampler.ProportionalBatchSampler\n :members:\n```\n"
},
{
"path": "docs/package_reference/sentence_transformer/trainer.md",
"content": "# Trainer\n\n## SentenceTransformerTrainer\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.trainer.SentenceTransformerTrainer\n :members:\n :inherited-members:\n :exclude-members: autocast_smart_context_manager, collect_features, compute_loss_context_manager, evaluation_loop, floating_point_ops, get_decay_parameter_names, get_optimizer_cls_and_kwargs, init_hf_repo, log_metrics, metrics_format, num_examples, num_tokens, predict, prediction_loop, prediction_step, save_metrics, save_state, training_step\n```\n"
},
{
"path": "docs/package_reference/sentence_transformer/training_args.md",
"content": "# Training Arguments\n\n## SentenceTransformerTrainingArguments\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.training_args.SentenceTransformerTrainingArguments\n :members:\n :inherited-members:\n```\n"
},
{
"path": "docs/package_reference/sparse_encoder/SparseEncoder.md",
"content": "# SparseEncoder\n\n## SparseEncoder\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.SparseEncoder\n :members:\n :inherited-members: \n :exclude-members: fit, old_fit, save, save_to_hub, add_module, append, apply, buffers, children, extra_repr, forward, get_buffer, get_extra_state, get_parameter, get_submodule, ipu, load_state_dict, modules, named_buffers, named_children, named_modules, named_parameters, parameters, register_backward_hook, register_buffer, register_forward_hook, register_forward_pre_hook, register_full_backward_hook, register_full_backward_pre_hook, register_load_state_dict_post_hook, register_module, register_parameter, register_state_dict_pre_hook, requires_grad_, set_extra_state, share_memory, state_dict, to_empty, type, xpu, zero_grad, truncate_sentence_embeddings, encode_multi_process\n```\n\n## SparseEncoderModelCardData\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.model_card.SparseEncoderModelCardData\n :members:\n```\n\n## SimilarityFunction\n```{eval-rst}\n.. autoclass:: sentence_transformers.SimilarityFunction\n :members:\n``` "
},
{
"path": "docs/package_reference/sparse_encoder/callbacks.md",
"content": "# Callbacks\n\n## SpladeRegularizerWeightSchedulerCallback\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.callbacks.splade_callbacks.SpladeRegularizerWeightSchedulerCallback\n```\n"
},
{
"path": "docs/package_reference/sparse_encoder/evaluation.md",
"content": "# Evaluation\n\n`sentence_transformers.sparse_encoder.evaluation` defines different classes, that can be used to evaluate the SparseEncoder model during training.\n\n## SparseInformationRetrievalEvaluator\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.evaluation.SparseInformationRetrievalEvaluator\n```\n\n## SparseNanoBEIREvaluator\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.evaluation.SparseNanoBEIREvaluator\n``` \n\n## SparseEmbeddingSimilarityEvaluator\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.evaluation.SparseEmbeddingSimilarityEvaluator\n```\n\n## SparseBinaryClassificationEvaluator\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.evaluation.SparseBinaryClassificationEvaluator\n```\n\n## SparseTripletEvaluator\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.evaluation.SparseTripletEvaluator\n```\n\n## SparseRerankingEvaluator\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.evaluation.SparseRerankingEvaluator\n```\n\n## SparseTranslationEvaluator\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.evaluation.SparseTranslationEvaluator\n```\n\n## SparseMSEEvaluator\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.evaluation.SparseMSEEvaluator\n```\n\n## ReciprocalRankFusionEvaluator\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.evaluation.ReciprocalRankFusionEvaluator"
},
{
"path": "docs/package_reference/sparse_encoder/index.rst",
"content": "Sparse Encoder\n=============\n\n.. toctree::\n\n SparseEncoder\n trainer\n training_args\n losses\n ../sentence_transformer/sampler\n evaluation\n models\n callbacks\n search_engines"
},
{
"path": "docs/package_reference/sparse_encoder/losses.md",
"content": "# Losses\n\n`sentence_transformers.sparse_encoder.losses` defines different loss functions that can be used to fine-tune saprse embedding models on training data. The choice of loss function plays a critical role when fine-tuning the model. It determines how well our embedding model will work for the specific downstream task.\n\nSadly, there is no \"one size fits all\" loss function. Which loss function is suitable depends on the available training data and on the target task. Consider checking out the [Loss Overview](../../sparse_encoder/loss_overview.md) to help narrow down your choice of loss function(s).\n\n```{eval-rst}\n.. warning:: \n To train a :class:`~sentence_transformers.sparse_encoder.SparseEncoder`, you need either :class:`~sentence_transformers.sparse_encoder.losses.SpladeLoss` or :class:`~sentence_transformers.sparse_encoder.losses.CSRLoss`, depending on the architecture. These are wrapper losses that add sparsity regularization on top of a main loss function, which must be provided as a parameter. The only loss that can be used independently is :class:`~sentence_transformers.sparse_encoder.losses.SparseMSELoss`, as it performs embedding-level distillation, ensuring sparsity by directly copying the teacher's sparse embedding.\n\n```\n\n## SpladeLoss\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.losses.SpladeLoss\n```\n\n## CachedSpladeLoss\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.losses.CachedSpladeLoss\n```\n\n## FlopsLoss\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.losses.FlopsLoss\n```\n\n## CSRLoss\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.losses.CSRLoss\n```\n\n## CSRReconstructionLoss\n\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.losses.CSRReconstructionLoss\n```\n\n## SparseMultipleNegativesRankingLoss\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.losses.SparseMultipleNegativesRankingLoss\n```\n\n## SparseMarginMSELoss\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.losses.SparseMarginMSELoss\n```\n\n## SparseDistillKLDivLoss\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.losses.SparseDistillKLDivLoss\n``` \n\n## SparseTripletLoss\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.losses.SparseTripletLoss\n```\n\n## SparseCosineSimilarityLoss\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.losses.SparseCosineSimilarityLoss\n```\n\n## SparseCoSENTLoss\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.losses.SparseCoSENTLoss\n```\n\n## SparseAnglELoss\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.losses.SparseAnglELoss\n```\n\n## SparseMSELoss\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.losses.SparseMSELoss\n```"
},
{
"path": "docs/package_reference/sparse_encoder/models.md",
"content": "# Modules\n\n`sentence_transformers.sparse_encoder.models` defines different building blocks, that can be used to create SparseEncoder networks from scratch. For more details, see [Training Overview](../../sparse_encoder/training_overview.md).\nNote that modules from `sentence_transformers.models` can also be used for Sparse models, such as `sentence_transformers.models.Transformer` from [SentenceTransformer > Modules](../sentence_transformer/models.md)\n## SPLADE Pooling\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.models.SpladePooling\n```\n\n## MLM Transformer\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.models.MLMTransformer\n```\n\n## SparseAutoEncoder\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.models.SparseAutoEncoder\n```\n\n## SparseStaticEmbedding\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.models.SparseStaticEmbedding\n``` "
},
{
"path": "docs/package_reference/sparse_encoder/search_engines.md",
"content": "# Search Engines\n`sentence_transformers.sparse_encoder.search_engines` defines different helpful functions to integrate with vector databases and search engines the sparse embeddings produced.\n\n\n```{eval-rst}\n.. automodule:: sentence_transformers.sparse_encoder.search_engines\n :members: semantic_search_qdrant, semantic_search_elasticsearch, semantic_search_seismic, semantic_search_opensearch\n```\n"
},
{
"path": "docs/package_reference/sparse_encoder/trainer.md",
"content": "# Trainer\n\n## SparseEncoderTrainer\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.SparseEncoderTrainer\n :members:\n :inherited-members:\n :exclude-members: autocast_smart_context_manager, collect_features, compute_loss_context_manager, evaluation_loop, floating_point_ops, get_decay_parameter_names, get_optimizer_cls_and_kwargs, init_hf_repo, log_metrics, metrics_format, num_examples, num_tokens, predict, prediction_loop, prediction_step, save_metrics, save_state, training_step\n``` "
},
{
"path": "docs/package_reference/sparse_encoder/training_args.md",
"content": "# Training Arguments\n\n## SparseEncoderTrainingArguments\n```{eval-rst}\n.. autoclass:: sentence_transformers.sparse_encoder.training_args.SparseEncoderTrainingArguments\n :members:\n :inherited-members:\n``` "
},
{
"path": "docs/package_reference/util.md",
"content": "# util\n\n`sentence_transformers.util` defines different helpful functions to work with text embeddings.\n\n## Helper Functions\n\n```{eval-rst}\n.. automodule:: sentence_transformers.util\n :members: paraphrase_mining, semantic_search, community_detection, http_get, truncate_embeddings, normalize_embeddings, is_training_available, mine_hard_negatives\n```\n\n## Model Optimization\n\n```{eval-rst}\n.. automodule:: sentence_transformers.backend\n :members: export_optimized_onnx_model, export_dynamic_quantized_onnx_model, export_static_quantized_openvino_model\n```\n\n## Similarity Metrics\n\n```{eval-rst}\n.. automodule:: sentence_transformers.util\n :members: cos_sim, pairwise_cos_sim, dot_score, pairwise_dot_score, manhattan_sim, pairwise_manhattan_sim, euclidean_sim, pairwise_euclidean_sim\n```\n"
},
{
"path": "docs/pretrained-models/ce-msmarco.md",
"content": "# MS MARCO Cross-Encoders\n\n[MS MARCO](https://microsoft.github.io/msmarco/) is a large scale information retrieval corpus that was created based on real user search queries using Bing search engine. The provided models can be used for semantic search, i.e., given keywords / a search phrase / a question, the model will find passages that are relevant for the search query.\n\nThe training data consists of over 500k examples, while the complete corpus consists of over 8.8 million passages.\n\n## Usage with SentenceTransformers\nPre-trained models can be used like this:\n```python\nfrom sentence_transformers import CrossEncoder\n\nmodel = CrossEncoder(\"model_name\", max_length=512)\nscores = model.predict(\n [(\"Query\", \"Paragraph1\"), (\"Query\", \"Paragraph2\"), (\"Query\", \"Paragraph3\")]\n)\n```\n\n## Usage with Transformers\n\n```python\nfrom transformers import AutoTokenizer, AutoModelForSequenceClassification\nimport torch\n\nmodel = AutoModelForSequenceClassification.from_pretrained(\"model_name\")\ntokenizer = AutoTokenizer.from_pretrained(\"model_name\")\n\nfeatures = tokenizer([\"Query\", \"Query\"], [\"Paragraph1\", \"Paragraph2\"], padding=True, truncation=True, return_tensors=\"pt\")\n\nmodel.eval()\nwith torch.no_grad():\n scores = model(**features).logits\n print(scores)\n```\n\n\n## Models & Performance\n\nIn the following table, we provide various pre-trained Cross-Encoders together with their performance on the [TREC Deep Learning 2019](https://microsoft.github.io/TREC-2019-Deep-Learning/) and the [MS Marco Passage Reranking](https://github.com/microsoft/MSMARCO-Passage-Ranking/) dataset. \n\n\n| Model-Name | NDCG@10 (TREC DL 19) | MRR@10 (MS Marco Dev) | Docs / Sec |\n| ------------- | :-------------: | :-----: | ---: | \n| **Version 2 models** | | | \n| cross-encoder/ms-marco-TinyBERT-L2-v2 | 69.84 | 32.56 | 9000\n| cross-encoder/ms-marco-MiniLM-L2-v2 | 71.01 | 34.85 | 4100\n| cross-encoder/ms-marco-MiniLM-L4-v2 | 73.04 | 37.70 | 2500\n| cross-encoder/ms-marco-MiniLM-L6-v2 | 74.30 | 39.01 | 1800\n| cross-encoder/ms-marco-MiniLM-L12-v2 | 74.31 | 39.02 | 960\n| **Version 1 models** | | | \n| cross-encoder/ms-marco-TinyBERT-L2 | 67.43 | 30.15 | 9000 | \n| cross-encoder/ms-marco-TinyBERT-L4 | 68.09 | 34.50 | 2900 | \n| cross-encoder/ms-marco-TinyBERT-L6 | 69.57 | 36.13 | 680 | \n| cross-encoder/ms-marco-electra-base | 71.99 | 36.41 | 340 | \n| **Other models** | | | |\n| nboost/pt-tinybert-msmarco | 63.63 | 28.80 | 2900 | \n| nboost/pt-bert-base-uncased-msmarco | 70.94 | 34.75 | 340 | \n| nboost/pt-bert-large-msmarco | 73.36 | 36.48 | 100 | \n| Capreolus/electra-base-msmarco | 71.23 | 36.89 | 340 | \n| amberoad/bert-multilingual-passage-reranking-msmarco | 68.40 | 35.54 | 330 | \n| sebastian-hofstaetter/distilbert-cat-margin_mse-T2-msmarco | 72.82 | 37.88 | 720\n \n Note: Runtime was computed on a V100 GPU with Hugging Face Transformers v4. \n"
},
{
"path": "docs/pretrained-models/dpr.md",
"content": "# DPR-Models\nIn [Dense Passage Retrieval for Open-Domain Question Answering](https://huggingface.co/papers/2004.04906) Karpukhin et al. trained models based on [Google's Natural Questions dataset](https://ai.google.com/research/NaturalQuestions):\n- **facebook-dpr-ctx_encoder-single-nq-base** \n- **facebook-dpr-question_encoder-single-nq-base**\n\nThey also trained models on the combination of Natural Questions, TriviaQA, WebQuestions, and CuratedTREC.\n- **facebook-dpr-ctx_encoder-multiset-base** \n- **facebook-dpr-question_encoder-multiset-base**\n\n\nThere is one model to encode passages and one model to encode question / queries.\n\n## Usage\n\nTo encode paragraphs, you need to provide a title (e.g. the Wikipedia article title) and the text passage. These must be separated with a `[SEP]` token. For encoding paragraphs, we use the **ctx_encoder**.\n\nQueries are encoded with **question_encoder**:\n```python\nfrom sentence_transformers import SentenceTransformer, util\n\npassage_encoder = SentenceTransformer(\"facebook-dpr-ctx_encoder-single-nq-base\")\n\npassages = [\n \"London [SEP] London is the capital and largest city of England and the United Kingdom.\",\n \"Paris [SEP] Paris is the capital and most populous city of France.\",\n \"Berlin [SEP] Berlin is the capital and largest city of Germany by both area and population.\",\n]\n\npassage_embeddings = passage_encoder.encode(passages)\n\nquery_encoder = SentenceTransformer(\"facebook-dpr-question_encoder-single-nq-base\")\nquery = \"What is the capital of England?\"\nquery_embedding = query_encoder.encode(query)\n\n# Important: You must use dot-product, not cosine_similarity\nscores = util.dot_score(query_embedding, passage_embeddings)\nprint(\"Scores:\", scores)\n```\n\n**Important note:** When you use these models, you have to use them with dot-product (e.g. as implemented in `util.dot_score`) and not with cosine similarity.\n"
},
{
"path": "docs/pretrained-models/msmarco-v1.md",
"content": "# MSMARCO Models\n[MS MARCO](https://microsoft.github.io/msmarco/) is a large scale information retrieval corpus that was created based on real user search queries using Bing search engine. The provided models can be used for semantic search, i.e., given keywords / a search phrase / a question, the model will find passages that are relevant for the search query.\n\nThe training data consists of over 500k examples, while the complete corpus consist of over 8.8 Million passages.\n \n\n\n## Version History \n\n### v1\nVersion 1 models were trained on the training set of MS Marco Passage retrieval task. The models were trained using in-batch negative sampling via the MultipleNegativesRankingLoss with a scaling factor of 20 and a batch size of 128.\n\nThey can be used like this:\n```python\nfrom sentence_transformers import SentenceTransformer, util\n\nmodel = SentenceTransformer(\"distilroberta-base-msmarco-v1\")\n\nquery_embedding = model.encode(\"[QRY] \" + \"How big is London\")\npassage_embedding = model.encode(\"[DOC] \" + \"London has 9,787,426 inhabitants at the 2011 census\")\n\nprint(\"Similarity:\", util.pytorch_cos_sim(query_embedding, passage_embedding))\n```\n\n**Models**:\n- **distilroberta-base-msmarco-v1** - Performance MSMARCO dev dataset (queries.dev.small.tsv) MRR@10: 23.28"
},
{
"path": "docs/pretrained-models/msmarco-v2.md",
"content": "# MSMARCO Models (Version 2)\n[MS MARCO](https://microsoft.github.io/msmarco/) is a large scale information retrieval corpus that was created based on real user search queries using Bing search engine. The provided models can be used for semantic search, i.e., given keywords / a search phrase / a question, the model will find passages that are relevant for the search query.\n\nThe training data consists of over 500k examples, while the complete corpus consist of over 8.8 Million passages.\n \n## Usage\n```python\nfrom sentence_transformers import SentenceTransformer, util\n\nmodel = SentenceTransformer(\"msmarco-distilroberta-base-v2\")\n\nquery_embedding = model.encode(\"How big is London\")\npassage_embedding = model.encode(\"London has 9,787,426 inhabitants at the 2011 census\")\n\nprint(\"Similarity:\", util.pytorch_cos_sim(query_embedding, passage_embedding))\n```\n\n\nFor more details on the usage, see [Applications - Information Retrieval](../../examples/sentence_transformer/applications/retrieve_rerank/README.md)\n\n\n## Performance\nPerformance is evaluated on [TREC-DL 2019](https://microsoft.github.io/TREC-2019-Deep-Learning/), which is a query-passage retrieval task where multiple queries have been annotated as with their relevance with respect to the given query. Further, we evaluate on the [MS Marco Passage Retrieval](https://github.com/microsoft/MSMARCO-Passage-Ranking/) dataset. \n\nAs baseline we show the results for lexical search with BM25 using Elasticsearch.\n\n| Approach | NDCG@10 (TREC DL 19 Reranking) | MRR@10 (MS Marco Dev) | \n| ------------- |:-------------: | :---: |\n| BM25 (Elasticsearch) | 45.46 | 17.29 |\n| msmarco-distilroberta-base-v2 | 65.65 | 28.55 | \n| msmarco-roberta-base-v2 | 67.18 | 29.17 | \n| msmarco-distilbert-base-v2 | 68.35 | 30.77 |\n\n\n\n## Version History \n\n- [Version 1](msmarco-v1.md)\n"
},
{
"path": "docs/pretrained-models/msmarco-v3.md",
"content": "# MSMARCO Models \n[MS MARCO](https://microsoft.github.io/msmarco/) is a large scale information retrieval corpus that was created based on real user search queries using Bing search engine. The provided models can be used for semantic search, i.e., given keywords / a search phrase / a question, the model will find passages that are relevant for the search query.\n\nThe training data consists of over 500k examples, while the complete corpus consist of over 8.8 Million passages.\n \n## Usage\n```python\nfrom sentence_transformers import SentenceTransformer, util\n\nmodel = SentenceTransformer(\"msmarco-distilbert-base-v3\")\n\nquery_embedding = model.encode(\"How big is London\")\npassage_embedding = model.encode(\"London has 9,787,426 inhabitants at the 2011 census\")\n\nprint(\"Similarity:\", util.cos_sim(query_embedding, passage_embedding))\n```\n\n\nFor more details on the usage, see [Applications - Information Retrieval](../../examples/sentence_transformer/applications/retrieve_rerank/README.md)\n\n\n## Performance\nPerformance is evaluated on [TREC-DL 2019](https://microsoft.github.io/TREC-2019-Deep-Learning/), which is a query-passage retrieval task where multiple queries have been annotated as with their relevance with respect to the given query. Further, we evaluate on the [MS Marco Passage Retrieval](https://github.com/microsoft/MSMARCO-Passage-Ranking/) dataset. \n\nAs baseline we show the results for lexical search with BM25 using Elasticsearch.\n\n| Approach | NDCG@10 (TREC DL 19 Reranking) | MRR@10 (MS Marco Dev) | Queries (GPU / CPU) | Docs (GPU / CPU)\n| ------------- |:-------------: | :---: | :---: | :---: |\n| **Models tuned for cosine-similarity** | |\n| msmarco-MiniLM-L6-v3 | 67.46 | 32.27 | 18,000 / 750 | 2,800 / 180\n| msmarco-MiniLM-L12-v3 | 65.14 | 32.75 | 11,000 / 400 | 1,500 / 90\n| msmarco-distilbert-base-v3| 69.02 | 33.13 | 7,000 / 350 | 1,100 / 70\n| msmarco-distilbert-base-v4 | **70.24** | **33.79**| 7,000 / 350 | 1,100 / 70\n| msmarco-roberta-base-v3 | 69.08 | 33.01 | 4,000 / 170 | 540 / 30\n| **Models tuned for dot-product** | |\n| msmarco-distilbert-base-dot-prod-v3 | 68.42 | 33.04 | 7,000 / 350 | 1100 / 70\n| [msmarco-roberta-base-ance-firstp](https://github.com/microsoft/ANCE) | 67.84 | 33.01 | 4,000 / 170 | 540 / 30\n| [msmarco-distilbert-base-tas-b](https://huggingface.co/sebastian-hofstaetter/distilbert-dot-tas_b-b256-msmarco) | **71.04** | **34.43** | 7,000 / 350 | 1100 / 70\n| **Previous approaches** | | |\n| BM25 (Elasticsearch) | 45.46 | 17.29 |\n| msmarco-distilroberta-base-v2 | 65.65 | 28.55 | \n| msmarco-roberta-base-v2 | 67.18 | 29.17 | \n| msmarco-distilbert-base-v2 | 68.35 | 30.77 |\n\n**Notes:**\n- We provide two type of models, one tuned for **cosine-similarity**, the other for **dot-product**. Make sure to use the right method to compute the similarity between query and passages.\n- Models tuned for **cosine-similarity** will prefer the retrieval of shorter passages, while models for **dot-product** will prefer the retrieval of longer passages. Depending on your task, you might prefer the one or the other type of model.\n- **msmarco-roberta-base-ance-firstp** is the MSMARCO Dev Passage Retrieval ANCE(FirstP) 600K model from [ANCE](https://github.com/microsoft/ANCE). This model should be used with dot-product instead of cosine similarity.\n- **msmarco-distilbert-base-tas-b** uses the model from [sebastian-hofstaetter/distilbert-dot-tas_b-b256-msmarco](https://huggingface.co/sebastian-hofstaetter/distilbert-dot-tas_b-b256-msmarco). See the linked documentation / paper for more details.\n- Encoding speeds are per second and were measured on a V100 GPU and an 8 core Intel(R) Xeon(R) Platinum 8168 CPU @ 2.70GHz\n\n\n## Changes in v3\nThe models from v2 have been used for find for all training queries similar passages. An [MS MARCO Cross-Encoder](ce-msmarco.md) based on the electra-base-model has been then used to classify if these retrieved passages answer the question.\n\nIf they received a low score by the cross-encoder, we saved them as hard negatives: They got a high score from the bi-encoder, but a low-score from the (better) cross-encoder.\n\nWe then trained the v2 models with these new hard negatives.\n\n## Version History \n\n- [Version 2](msmarco-v2.md)\n- [Version 1](msmarco-v1.md)\n"
},
{
"path": "docs/pretrained-models/msmarco-v5.md",
"content": "# MSMARCO Models \n[MS MARCO](https://microsoft.github.io/msmarco/) is a large scale information retrieval corpus that was created based on real user search queries using Bing search engine. The provided models can be used for semantic search, i.e., given keywords / a search phrase / a question, the model will find passages that are relevant for the search query.\n\nThe training data consists of over 500k examples, while the complete corpus consist of over 8.8 Million passages.\n \n## Usage\n```python\nfrom sentence_transformers import SentenceTransformer, util\n\nmodel = SentenceTransformer(\"msmarco-distilbert-dot-v5\")\n\nquery_embedding = model.encode(\"How big is London\")\npassage_embedding = model.encode([\n \"London has 9,787,426 inhabitants at the 2011 census\",\n \"London is known for its financial district\",\n])\n\nprint(\"Similarity:\", util.dot_score(query_embedding, passage_embedding))\n```\n\n\nFor more details on the usage, see [Applications - Information Retrieval](../../examples/sentence_transformer/applications/retrieve_rerank/README.md)\n\n\n## Performance\nPerformance is evaluated on [TREC-DL 2019](https://microsoft.github.io/msmarco/TREC-Deep-Learning-2019) and [TREC-DL 2020](https://microsoft.github.io/msmarco/TREC-Deep-Learning-2020), which are a query-passage retrieval task where multiple queries have been annotated as with their relevance with respect to the given query. Further, we evaluate on the [MS Marco Passage Retrieval](https://github.com/microsoft/MSMARCO-Passage-Ranking/) dataset. \n\n\n| Approach | MRR@10 (MS Marco Dev) | NDCG@10 (TREC DL 19 Reranking) | NDCG@10 (TREC DL 20 Reranking) | Queries (GPU / CPU) | Docs (GPU / CPU)\n| ------------- | :-------------: | :-------------: | :---: | :---: | :---: |\n| **Models tuned with normalized embeddings** | |\n| [msmarco-MiniLM-L6-cos-v5](https://huggingface.co/sentence-transformers/msmarco-MiniLM-L6-cos-v5) | 32.27 | 67.46 | 64.73 | 18,000 / 750 | 2,800 / 180\n| [msmarco-MiniLM-L12-cos-v5](https://huggingface.co/sentence-transformers/msmarco-MiniLM-L12-cos-v5) | 32.75 | 65.14 | 67.48 | 11,000 / 400 | 1,500 / 90\n| [msmarco-distilbert-cos-v5](https://huggingface.co/sentence-transformers/msmarco-distilbert-cos-v5) | 33.79 | 70.24 | 66.24 | 7,000 / 350 | 1,100 / 70\n| [multi-qa-MiniLM-L6-cos-v1](https://huggingface.co/sentence-transformers/multi-qa-MiniLM-L6-cos-v1) | | 65.55 | 64.66 | 18,000 / 750 | 2,800 / 180 \n| [multi-qa-distilbert-cos-v1](https://huggingface.co/sentence-transformers/multi-qa-distilbert-cos-v1) | | 67.59 | 66.46 | 7,000 / 350 | 1,100 / 70\n| [multi-qa-mpnet-base-cos-v1](https://huggingface.co/sentence-transformers/multi-qa-mpnet-base-cos-v1) | | 67.78 |\t69.87 | 4,000 / 170 | 540 / 30\n| **Models tuned for dot-product** | |\n| [msmarco-distilbert-base-tas-b](https://huggingface.co/sentence-transformers/msmarco-distilbert-base-tas-b) | 34.43 | 71.04 | 69.78 | 7,000 / 350 | 1100 / 70\n| [msmarco-distilbert-dot-v5](https://huggingface.co/sentence-transformers/msmarco-distilbert-dot-v5) | 37.25 | 70.14 | 71.08 | 7,000 / 350 | 1100 / 70\n| [msmarco-bert-base-dot-v5](https://huggingface.co/sentence-transformers/msmarco-bert-base-dot-v5) | 38.08 | 70.51\t| 73.45 | 4,000 / 170 | 540 / 30\n| [multi-qa-MiniLM-L6-dot-v1](https://huggingface.co/sentence-transformers/multi-qa-MiniLM-L6-dot-v1) | | 66.70 | 65.98 | 18,000 / 750 | 2,800 / 180 \n| [multi-qa-distilbert-dot-v1](https://huggingface.co/sentence-transformers/multi-qa-distilbert-dot-v1) | | 68.05 | 70.49 | 7,000 / 350 | 1,100 / 70\n| [multi-qa-mpnet-base-dot-v1](https://huggingface.co/sentence-transformers/multi-qa-mpnet-base-dot-v1) | | 70.66 |\t71.18 | 4,000 / 170 | 540 / 30\n\n\n**Notes:**\n- We provide two type of models: One that produces **normalized embedding** and can be used with dot-product, cosine-similarity or euclidean distance (all three scoring function will produce the same results). The models tuned for **dot-product** will produce embeddings of different lengths and must be used with dot-product to find close items in a vector space.\n- Models with normalized embeddings will prefer the retrieval of shorter passages, while models tuned for **dot-product** will prefer the retrieval of longer passages. Depending on your task, you might prefer the one or the other type of model.\n- Encoding speeds are per second and were measured on a V100 GPU and an 8 core Intel(R) Xeon(R) Platinum 8168 CPU @ 2.70GHz\n\n\n## Changes in v5\n- Models with normalized embeddings were added: These are the v3 cosine-similarity models, but with an additional normalize layer on-top.\n- New models trained with MarginMSE loss trained: msmarco-distilbert-dot-v5 and msmarco-bert-base-dot-v5\n\n## Changes in v4\n- Just one new model was trained with better hard negatives, leading to a small improvement compared to v3\n\n## Changes in v3\nThe models from v2 have been used for find for all training queries similar passages. An [MS MARCO Cross-Encoder](ce-msmarco.md) based on the electra-base-model has been then used to classify if these retrieved passages answer the question.\n\nIf they received a low score by the cross-encoder, we saved them as hard negatives: They got a high score from the bi-encoder, but a low-score from the (better) cross-encoder.\n\nWe then trained the v2 models with these new hard negatives.\n\n## Version History \n\n- [Version 3](msmarco-v3.md)\n- [Version 2](msmarco-v2.md)\n- [Version 1](msmarco-v1.md)\n"
},
{
"path": "docs/pretrained-models/nli-models.md",
"content": "# NLI Models\nConneau et al., 2017, show in the InferSent-Paper ([Supervised Learning of Universal Sentence Representations from Natural Language Inference Data](https://huggingface.co/papers/1705.02364)) that training on Natural Language Inference (NLI) data can produce universal sentence embeddings.\n\nThe datasets labeled sentence pairs with the labels *entail*, *contradict*, and *neutral*. For both sentences, we compute a sentence embedding. These two embeddings are concatenated and passed to softmax classifier to derive the final label.\n\nAs shown, this produces sentence embeddings that can be used for various use cases like clustering or semantic search.\n\n# Datasets\nWe train the models on the [SNLI](https://nlp.stanford.edu/projects/snli/) and on the [MultiNLI](https://www.nyu.edu/projects/bowman/multinli/) dataset. We call the combination of the two datasets AllNLI.\n\nFor a training example, see [examples/sentence_transformer/training/nli/training_nli.py](../../examples/sentence_transformer/training/nli/training_nli.py). \n\n# Pretrained models\nWe provide the various pre-trained models. The performance was evaluated on the test set of the STS benchmark dataset ([docs](https://web.archive.org/web/20231128064114/http://ixa2.si.ehu.eus/stswiki/index.php/STSbenchmark), [dataset](https://huggingface.co/datasets/sentence-transformers/stsb)) using Spearman rank correlation.\n\n[» Full List of NLI & STS Models](https://docs.google.com/spreadsheets/d/14QplCdTCDwEmTqrn1LH4yrbKvdogK4oQvYO1K1aPR5M/edit#gid=0)\n\n# Performance Comparison\nHere are the performances on the STS benchmark for other sentence embeddings methods. They were also computed by using cosine-similarity and Spearman rank correlation:\n- Avg. GloVe embeddings: 58.02 \n- BERT-as-a-service avg. embeddings: 46.35 \n- BERT-as-a-service CLS-vector: 16.50 \n- InferSent - GloVe: 68.03 \n- Universal Sentence Encoder: 74.92\n\n# Applications\nThis model works well in accessing the coarse-grained similarity between sentences. For application examples, see [semantic_textual_similarity](../sentence_transformer/usage/semantic_textual_similarity.rst) and [semantic search](../../examples/sentence_transformer/applications/semantic-search/README.md)."
},
{
"path": "docs/pretrained-models/nq-v1.md",
"content": "# Natural Questions Models\n[Google's Natural Questions dataset](https://ai.google.com/research/NaturalQuestions) consists of about 100k real search queries from Google with the respective, relevant passage from Wikipedia. Models trained on this dataset work well for question-answer retrieval.\n\n## Usage\n\n```python\nfrom sentence_transformers import SentenceTransformer, util\n\nmodel = SentenceTransformer(\"nq-distilbert-base-v1\")\n\nquery_embedding = model.encode(\"How many people live in London?\")\n\n# The passages are encoded as [ [title1, text1], [title2, text2], ...]\npassage_embedding = model.encode(\n [[\"London\", \"London has 9,787,426 inhabitants at the 2011 census.\"]]\n)\n\nprint(\"Similarity:\", util.cos_sim(query_embedding, passage_embedding))\n```\n\nNote: For the passage, we have to encode the Wikipedia article title together with a text paragraph from that article.\n\n\n## Performance\nThe models are evaluated on the Natural Questions development dataset using MRR@10.\n\n| Approach | MRR@10 (NQ dev set small) | \n| ------------- |:-------------: |\n| nq-distilbert-base-v1 | 72.36 |\n| *Other models* | |\n| [DPR](https://huggingface.co/transformers/model_doc/dpr.html) | 58.96 |"
},
{
"path": "docs/pretrained-models/sts-models.md",
"content": "# STS Models\nThe models were first trained on [NLI data](nli-models.md), then we fine-tuned them on the STS benchmark dataset ([docs](https://web.archive.org/web/20231128064114/http://ixa2.si.ehu.eus/stswiki/index.php/STSbenchmark), [dataset](https://huggingface.co/datasets/sentence-transformers/stsb)). This generate sentence embeddings that are especially suitable to measure the semantic similarity between sentence pairs.\n\n# Datasets\nWe use the training file from the [STS benchmark dataset](https://huggingface.co/datasets/sentence-transformers/stsb).\n\nFor a training example, see:\n- [examples/sentence_transformer/training_stsbenchmark.py](https://github.com/huggingface/sentence-transformers/blob/main/examples/sentence_transformer/training/sts/training_stsbenchmark.py) - Train directly on STS data\n- [examples/sentence_transformer/training_stsbenchmark_continue_training.py ](https://github.com/huggingface/sentence-transformers/blob/main/examples/sentence_transformer/training/sts/training_stsbenchmark_continue_training.py) - First train on NLI, than train on STS data.\n\n# Pre-trained models\n We provide the following pre-trained models:\n\n[» Full List of STS Models](https://docs.google.com/spreadsheets/d/14QplCdTCDwEmTqrn1LH4yrbKvdogK4oQvYO1K1aPR5M/edit#gid=0)\n\n# Performance Comparison\nHere are the performances on the STS benchmark for other sentence embeddings methods. They were also computed by using cosine-similarity and Spearman rank correlation. Note, these models were not-fined on the STS benchmark.\n\n- Avg. GloVe embeddings: 58.02 \n- BERT-as-a-service avg. embeddings: 46.35 \n- BERT-as-a-service CLS-vector: 16.50 \n- InferSent - GloVe: 68.03 \n- Universal Sentence Encoder: 74.92\n"
},
{
"path": "docs/pretrained-models/wikipedia-sections-models.md",
"content": "# Wikipedia Sections Models\nThe `wikipedia-sections-models` implement the idea from Ein Dor et al., 2018, [Learning Thematic Similarity Metric Using Triplet Networks](https://aclweb.org/anthology/P18-2009).\n\nIt was trained with a triplet-loss: The anchor and the positive example were sentences from the same section from an wikipedia article, for example, from the History section of the London article. The negative example came from a different section from the same article, for example, from the Education section of the London article.\n\n# Dataset\nWe use dataset from Ein Dor et al., 2018, [Learning Thematic Similarity Metric Using Triplet Networks](https://aclweb.org/anthology/P18-2009).\n\nSee [examples/sentence_transformer/training/other/training_wikipedia_sections.py](../../examples/sentence_transformer/training/other/training_wikipedia_sections.py) for how to train on this dataset.\n\n\n# Pre-trained models\nWe provide the following pre-trained models:\n\n- **bert-base-wikipedia-sections-mean-tokens**: 80.42% accuracy on test set.\n\nYou can use them in the following way:\n```\nfrom sentence_transformers import SentenceTransformer\n\nembedder = SentenceTransformer(\"bert-base-wikipedia-sections-mean-tokens\")\n```\n\n# Performance Comparison\nPerformance (accuracy) reported by Dor et al.:\n- mean-vectors: 0.65\n- skip-thoughts-CS: 0.615\n- skip-thoughts-SICK: 0.547\n- triplet-sen: 0.74\n\n\n# Applications\nThe models achieve a rather low performance on the STS benchmark dataset. The reason for this is the training objective: An anchor, a positive and a negative example are presented. The network must only learn to differentiate what the positive and what the negative example is by ensuring that the negative example is further away from the anchor than the positive example.\n\nHowever, it does not matter how far the negative example is away, it can be little or really far away. This makes this model rather bad for deciding if a pair is somewhat similar. It learns only to recognize similar pairs (high scores) and dissimilar pairs (low scores).\n\nHowever, this model works well for **fine-grained clustering**. \n\n"
},
{
"path": "docs/publications.md",
"content": "# Publications\n\nIf you find this repository helpful, feel free to cite our publication [Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks](https://huggingface.co/papers/1908.10084):\n\n```bibtex\n@inproceedings{reimers-2019-sentence-bert,\n title = \"Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks\",\n author = \"Reimers, Nils and Gurevych, Iryna\",\n booktitle = \"Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing\",\n month = \"11\",\n year = \"2019\",\n publisher = \"Association for Computational Linguistics\",\n url = \"http://arxiv.org/abs/1908.10084\",\n}\n```\n\nIf you use one of the multilingual models, feel free to cite our publication [Making Monolingual Sentence Embeddings Multilingual using Knowledge Distillation](https://huggingface.co/papers/2004.09813):\n\n```bibtex\n@inproceedings{reimers-2020-multilingual-sentence-bert,\n title = \"Making Monolingual Sentence Embeddings Multilingual using Knowledge Distillation\",\n author = \"Reimers, Nils and Gurevych, Iryna\",\n booktitle = \"Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing\",\n month = \"11\",\n year = \"2020\",\n publisher = \"Association for Computational Linguistics\",\n url = \"https://arxiv.org/abs/2004.09813\",\n}\n```\n\nIf you use the code for [data augmentation](https://github.com/huggingface/sentence-transformers/tree/main/examples/sentence_transformer/training/data_augmentation), feel free to cite our publication [Augmented SBERT: Data Augmentation Method for Improving Bi-Encoders for Pairwise Sentence Scoring Tasks](https://huggingface.co/papers/2010.08240):\n\n```bibtex\n@inproceedings{thakur-2020-AugSBERT,\n title = \"Augmented {SBERT}: Data Augmentation Method for Improving Bi-Encoders for Pairwise Sentence Scoring Tasks\",\n author = \"Thakur, Nandan and Reimers, Nils and Daxenberger, Johannes and Gurevych, Iryna\",\n booktitle = \"Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies\",\n month = \"6\",\n year = \"2021\",\n address = \"Online\",\n publisher = \"Association for Computational Linguistics\",\n url = \"https://arxiv.org/abs/2010.08240\",\n pages = \"296--310\",\n}\n```\n\nIf you use the models for [MS MARCO](pretrained-models/msmarco-v2.md), feel free to cite the paper: [The Curse of Dense Low-Dimensional Information Retrieval for Large Index Sizes](https://huggingface.co/papers/2012.14210)\n\n```bibtex\n@inproceedings{reimers-2020-Curse_Dense_Retrieval,\n title = \"The Curse of Dense Low-Dimensional Information Retrieval for Large Index Sizes\",\n author = \"Reimers, Nils and Gurevych, Iryna\",\n booktitle = \"Proceedings of the 59th Annual Meeting of the Association for Computational Linguistics and the 11th International Joint Conference on Natural Language Processing (Volume 2: Short Papers)\",\n month = \"8\",\n year = \"2021\",\n address = \"Online\",\n publisher = \"Association for Computational Linguistics\",\n url = \"https://arxiv.org/abs/2012.14210\",\n pages = \"605--611\",\n}\n```\n\nWhen you use the unsupervised learning example, please have a look at: [TSDAE: Using Transformer-based Sequential Denoising Auto-Encoderfor Unsupervised Sentence Embedding Learning](https://huggingface.co/papers/2104.06979):\n\n```bibtex\n@inproceedings{wang-2021-TSDAE,\n title = \"TSDAE: Using Transformer-based Sequential Denoising Auto-Encoderfor Unsupervised Sentence Embedding Learning\",\n author = \"Wang, Kexin and Reimers, Nils and Gurevych, Iryna\", \n booktitle = \"Findings of the Association for Computational Linguistics: EMNLP 2021\",\n month = nov,\n year = \"2021\",\n address = \"Punta Cana, Dominican Republic\",\n publisher = \"Association for Computational Linguistics\",\n pages = \"671--688\",\n url = \"https://arxiv.org/abs/2104.06979\",\n}\n```\n\nWhen you use the GenQ learning example, please have a look at: [BEIR: A Heterogeneous Benchmark for Zero-shot Evaluation of Information Retrieval Models](https://huggingface.co/papers/2104.08663):\n\n```bibtex\n@inproceedings{thakur-2021-BEIR,\n title = \"BEIR: A Heterogeneous Benchmark for Zero-shot Evaluation of Information Retrieval Models\",\n author = {Thakur, Nandan and Reimers, Nils and R{\\\"{u}}ckl{\\'{e}}, Andreas and Srivastava, Abhishek and Gurevych, Iryna}, \n booktitle={Thirty-fifth Conference on Neural Information Processing Systems (NeurIPS 2021) - Datasets and Benchmarks Track (Round 2)},\n month = \"4\",\n year = \"2021\",\n url = \"https://arxiv.org/abs/2104.08663\",\n}\n```\n\nWhen you use GPL, please have a look at: [GPL: Generative Pseudo Labeling for Unsupervised Domain Adaptation of Dense Retrieval](https://huggingface.co/papers/2112.07577):\n\n```bibtex\n@inproceedings{wang-2021-GPL,\n title = \"GPL: Generative Pseudo Labeling for Unsupervised Domain Adaptation of Dense Retrieval\",\n author = \"Wang, Kexin and Thakur, Nandan and Reimers, Nils and Gurevych, Iryna\", \n journal= \"arXiv preprint arXiv:2112.07577\",\n month = \"12\",\n year = \"2021\",\n url = \"https://arxiv.org/abs/2112.07577\",\n}\n```\n\n**Repositories using SentenceTransformers**\n\n- **[haystack](https://github.com/deepset-ai/haystack)** - Neural Search / Q&A\n- **[Top2Vec](https://github.com/ddangelov/Top2Vec)** - Topic modeling\n- **[txtai](https://github.com/neuml/txtai)** - AI-powered search engine\n- **[BERTTopic](https://github.com/MaartenGr/BERTopic)** - Topic model using SBERT embeddings\n- **[KeyBERT](https://github.com/MaartenGr/KeyBERT)** - Key phrase extraction using SBERT\n- **[contextualized-topic-models](https://github.com/MilaNLProc/contextualized-topic-models)** - Cross-Lingual Topic Modeling\n- **[covid-papers-browser](https://github.com/gsarti/covid-papers-browser)** - Semantic Search for Covid-19 papers\n- **[backprop](https://github.com/backprop-ai/backprop)** - Natural Language Engine that makes using state-of-the-art language models easy, accessible and scalable.\n\n**SentenceTransformers in Articles**\n\nIn the following you find a (selective) list of articles / applications using SentenceTransformers to do amazing stuff. Feel free to contact me (info@nils-reimers.de) to add you application here.\n\n- **December 2021 - [Sentence Transformer Fine-Tuning (SetFit): Outperforming GPT-3 on few-shot Text-Classification while being 1600 times smaller](https://towardsdatascience.com/sentence-transformer-fine-tuning-setfit-outperforms-gpt-3-on-few-shot-text-classification-while-d9a3788f0b4e?gi=4bdbaff416e3)**\n- **October 2021: [Natural Language Processing (NLP) for Semantic Search](https://www.pinecone.io/learn/nlp)**\n- **January 2021 - [Advance BERT model via transferring knowledge from Cross-Encoders to Bi-Encoders](https://resources.experfy.com/ai-ml/bert-model-transferring-knowledge-cross-encoders-bi-encoders/)**\n- **November 2020 - [How to Build a Semantic Search Engine With Transformers and Faiss](https://towardsdatascience.com/how-to-build-a-semantic-search-engine-with-transformers-and-faiss-dcbea307a0e8)**\n- **October 2020 - [Topic Modeling with BERT](https://medium.com/data-science/topic-modeling-with-bert-779f7db187e6)**\n- **September 2020 - [Elastic Transformers -\n Making BERT stretchy - Scalable Semantic Search on a Jupyter Notebook](https://medium.com/@mihail.dungarov/elastic-transformers-ae011e8f5b88)**\n- **July 2020 - [Simple Sentence Similarity Search with SentenceBERT](https://laptrinhx.com/simple-sentence-similarity-search-with-sentencebert-800684405/?fbclid=IwAR0rxdYS2DBGuHhijIRO_lsXqGc9BbjtDA-dDQM5Ng_StahT9xrHdRZuP9M)**\n- **May 2020 - [HN Time Machine: finally some Hacker News history!](https://peltarion.com/blog/applied-ai/hacker-news-time-machine)**\n- **May 2020 - [A complete guide to transfer learning from English to other Languages using Sentence Embeddings BERT Models](https://medium.com/data-science/a-complete-guide-to-transfer-learning-from-english-to-other-languages-using-sentence-embeddings-8c427f8804a9)**\n- **March 2020 - [Building a k-NN Similarity Search Engine using Amazon Elasticsearch and SageMaker](https://medium.com/data-science/building-a-k-nn-similarity-search-engine-using-amazon-elasticsearch-and-sagemaker-98df18d883bd)**\n- **February 2020 - [Semantic Search Engine with Sentence BERT](https://medium.com/@evergreenllc2020/semantic-search-engine-with-s-abbfb3cd9377)**\n\n**SentenceTransformers used in Research**\n\nSentenceTransformers is used in hundreds of research projects. For a list of publications, see [Google Scholar](https://scholar.google.com/scholar?oi=bibs&hl=de&cites=12599223809118664426) or [Semantic Scholar](https://www.semanticscholar.org/paper/Sentence-BERT%3A-Sentence-Embeddings-using-Siamese-Reimers-Gurevych/93d63ec754f29fa22572615320afe0521f7ec66d).\n"
},
{
"path": "docs/quickstart.rst",
"content": "Quickstart\n==========\n\nSentence Transformer\n--------------------\n\nCharacteristics of Sentence Transformer (a.k.a bi-encoder) models:\n\n1. Calculates a **fixed-size vector representation (embedding)** given **texts or images**.\n2. Embedding calculation is often **efficient**, embedding similarity calculation is **very fast**.\n3. Applicable for a **wide range of tasks**, such as semantic textual similarity, semantic search, clustering, classification, paraphrase mining, and more.\n4. Often used as a **first step in a two-step retrieval process**, where a Cross-Encoder (a.k.a. reranker) model is used to re-rank the top-k results from the bi-encoder.\n\nOnce you have `installed MultipleNegativesRankingLoss (a.k.a. InfoNCE or in-batch negatives loss) is commonly used to train the top performing embedding models. This data is often relatively cheap to obtain, and the models are generally very performant. CachedMultipleNegativesRankingLoss is often used to increase the batch size, resulting in superior performance.\n* `(sentence_A, sentence_B) pairs` with a `float similarity score`: CosineSimilarityLoss is traditionally used a lot, though more recently CoSENTLoss and AnglELoss are used as drop-in replacements with superior performance.\n\n## Custom Loss Functions\n\n```{eval-rst}\nAdvanced users can create and train with their own loss functions. Custom loss functions only have a few requirements:\n\n- They must be a subclass of :class:`torch.nn.Module`.\n- They must have ``model`` as the first argument in the constructor.\n- They must implement a ``forward`` method that accepts ``sentence_features`` and ``labels``. The former is a list of tokenized batches, one element for each column. These tokenized batches can be fed directly to the ``model`` being trained to produce embeddings. The latter is an optional tensor of labels. The method must return a single loss value or a dictionary of loss components (component names to loss values) that will be summed to produce the final loss value. When returning a dictionary, the individual components will be logged separately in addition to the summed loss, allowing you to monitor the individual components of the loss.\n\nTo get full support with the automatic model card generation, you may also wish to implement:\n\n- a ``get_config_dict`` method that returns a dictionary of loss parameters.\n- a ``citation`` property so your work gets cited in all models that train with the loss.\n\nConsider inspecting existing loss functions to get a feel for how loss functions are commonly implemented.\n```\n"
},
{
"path": "docs/sentence_transformer/pretrained_models.md",
"content": "# Pretrained Models\n\n```{eval-rst}\nWe provide various pre-trained Sentence Transformers models via our Sentence Transformers Hugging Face organization. Additionally, over 6,000 community Sentence Transformers models have been publicly released on the Hugging Face Hub. All models can be found here:\n\n* **Original models**: `Sentence Transformers Hugging Face organization learning_rate\n lr_scheduler_type\n warmup_ratio\n num_train_epochs\n max_steps\n per_device_train_batch_size\n per_device_eval_batch_size\n auto_find_batch_size\n fp16\n bf16\n load_best_model_at_end\n metric_for_best_model\n gradient_accumulation_steps\n gradient_checkpointing\n eval_accumulation_steps\n optim\n batch_sampler\n multi_dataset_batch_sampler\n prompts\n router_mapping\n learning_rate_mapping\n eval_strategy\n eval_steps\n save_strategy\n save_steps\n save_total_limit\n report_to\n run_name\n log_level\n logging_steps\n push_to_hub\n hub_model_id\n hub_strategy\n hub_private_repo\n model_kwargs will be passed on to OVBaseModel.from_pretrained(). Some notable arguments include:\n\n* ``file_name``: The name of the ONNX file to load. If not specified, will default to ``\"openvino_model.xml\"`` or otherwise ``\"openvino/openvino_model.xml\"``. This argument is useful for specifying optimized or quantized models.\n* ``export``: A boolean flag specifying whether the model will be exported. If not provided, ``export`` will be set to ``True`` if the model repository or directory does not already contain an OpenVINO model.\n\n.. tip::\n\n It's heavily recommended to save the exported model to prevent having to re-export it every time you run your code. You can do this by calling :meth:`model.save_pretrained() torch-fp32: PyTorch with float32 precision (default).\n torch-fp16: PyTorch with float16 precision, via model_kwargs={\"torch_dtype\": \"float16\"}.\n torch-bf16: PyTorch with bfloat16 precision, via model_kwargs={\"torch_dtype\": \"bfloat16\"}.\n onnx: ONNX with float32 precision, via backend=\"onnx\".\n onnx-O1: ONNX with float32 precision and O1 optimization, via export_optimized_onnx_model(..., optimization_config=\"O1\", ...) and backend=\"onnx\".\n onnx-O2: ONNX with float32 precision and O2 optimization, via export_optimized_onnx_model(..., optimization_config=\"O2\", ...) and backend=\"onnx\".\n onnx-O3: ONNX with float32 precision and O3 optimization, via export_optimized_onnx_model(..., optimization_config=\"O3\", ...) and backend=\"onnx\".\n onnx-O4: ONNX with float16 precision and O4 optimization, via export_optimized_onnx_model(..., optimization_config=\"O4\", ...) and backend=\"onnx\".\n onnx-qint8: ONNX quantized to int8 with \"avx512_vnni\", via export_dynamic_quantized_onnx_model(..., quantization_config=\"avx512_vnni\", ...) and backend=\"onnx\". The different quantization configurations resulted in roughly equivalent speedups.\n openvino: OpenVINO, via backend=\"openvino\".\n openvino-qint8: OpenVINO quantized to int8 via export_static_quantized_openvino_model(..., quantization_config=OVQuantizationConfig(), ...) and backend=\"openvino\".\n SpladeLoss implements a specialized loss function for SPLADE (Sparse Lexical and Expansion) models. It combines a main loss function with regularization terms to balance effectiveness and efficiency:\n\n1. Main loss: Supports all the losses from the Loss Table and Distillation, with SparseMultipleNegativesRankingLoss, SparseMarginMSELoss and SparseDistillKLDivLoss commonly used.\n2. Regularization loss: FlopsLoss is used to control sparsity, but supports custom regularizers.\n - `query_regularizer` and `document_regularizer` can be set to any custom regularization loss.\n - `query_regularizer_threshold` and `document_regularizer_threshold` can be set to control the sparsity strictness for queries and documents separately, setting the regularization loss to zero if an embedding has less than the threshold number of active (non-zero) dimensions.\n\n#### Cached SPLADE Loss\n\nThe CachedSpladeLoss is a variant of the SPLADE loss adopting GradCache, which allows for much larger batch sizes without additional GPU memory usage. It achieves this by computing and caching loss gradients in mini-batches. \n\nMain losses that use in-batch negatives, primarily SparseMultipleNegativesRankingLoss, benefit heavily from larger batch sizes, as it results in more negatives and a stronger training signal.\n\n### CSR Loss\n\nIf you are using the SparseAutoEncoder module, then you have to use the CSRLoss (Contrastive Sparse Representation Loss). It combines two components:\n\n1. Main loss: Supports all the losses from the Loss Table and Distillation, with SparseMultipleNegativesRankingLoss used in the CSR Paper.\n2. Reconstruction loss: CSRReconstructionLoss is used to ensure that sparse representation can faithfully reconstruct the original dense embeddings.\n\n## Loss Table\n\nLoss functions play a critical role in the performance of your fine-tuned model. Sadly, there is no \"one size fits all\" loss function. Ideally, this table should help narrow down your choice of loss function(s) by matching them to your data formats.\n\n```{eval-rst}\n.. note:: \n\n You can often convert one training data format into another, allowing more loss functions to be viable for your scenario. For example, ``(sentence_A, sentence_B) pairs`` with ``class`` labels can be converted into ``(anchor, positive, negative) triplets`` by sampling sentences with the same or different classes.\n```\n\n**Legend:** Loss functions marked with `★` are commonly recommended default choices.\n\n| Inputs | Labels | Appropriate Loss Functions |\n|---------------------------------------------------|------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| `(anchor, positive) pairs` | `none` | `SparseMultipleNegativesRankingLoss` ★ |\n| `(sentence_A, sentence_B) pairs` | `float similarity score between 0 and 1` | `SparseCoSENTLoss`SparseMultipleNegativesRankingLoss (a.k.a. InfoNCE or in-batch negatives loss) is commonly used to train the top performing embedding models. This data is often relatively cheap to obtain, and the models are generally very performant. Here for our sparse retrieval tasks, this format works well with SpladeLoss, CachedSpladeLoss, or CSRLoss, all typically using InfoNCE as their underlying loss function.\n\n* `(query, positive, negative_1, ..., negative_n)` format: This structure with multiple negatives is particularly effective with SpladeLoss configured with SparseMarginMSELoss, especially in knowledge distillation scenarios where a teacher model provides similarity scores. The strongest models are trained with distillation losses like SparseDistillKLDivLoss or SparseMarginMSELoss.\n\n## Custom Loss Functions\n\n```{eval-rst}\nAdvanced users can create and train with their own loss functions. Custom loss functions only have a few requirements:\n\n- They must be a subclass of :class:`torch.nn.Module`.\n- They must have ``model`` as the first argument in the constructor.\n- They must implement a ``forward`` method that accepts ``sentence_features`` and ``labels``. The former is a list of tokenized batches, one element for each column. These tokenized batches can be fed directly to the ``model`` being trained to produce embeddings. The latter is an optional tensor of labels. The method must return a single loss value or a dictionary of loss components (component names to loss values) that will be summed to produce the final loss value. When returning a dictionary, the individual components will be logged separately in addition to the summed loss, allowing you to monitor the individual components of the loss.\n\nTo get full support with the automatic model card generation, you may also wish to implement:\n\n- a ``get_config_dict`` method that returns a dictionary of loss parameters.\n- a ``citation`` property so your work gets cited in all models that train with the loss.\n\nConsider inspecting existing loss functions to get a feel for how loss functions are commonly implemented.\n```"
},
{
"path": "docs/sparse_encoder/pretrained_models.md",
"content": "# Pretrained Models\n\n```{eval-rst}\nSeveral Sparse Encoder models have been publicly released on the Hugging Face Hub:\n\n* **Community models**: `All Sparse Encoder models on Hugging Face learning_rate\n lr_scheduler_type\n warmup_ratio\n num_train_epochs\n max_steps\n per_device_train_batch_size\n per_device_eval_batch_size\n auto_find_batch_size\n fp16\n bf16\n load_best_model_at_end\n metric_for_best_model\n gradient_accumulation_steps\n gradient_checkpointing\n eval_accumulation_steps\n optim\n batch_sampler\n multi_dataset_batch_sampler\n prompts\n router_mapping\n learning_rate_mapping\n eval_strategy\n eval_steps\n save_strategy\n save_steps\n save_total_limit\n report_to\n run_name\n log_level\n logging_steps\n push_to_hub\n hub_model_id\n hub_strategy\n hub_private_repo\n model_kwargs will be passed on to OVBaseModel.from_pretrained(). Some notable arguments include:\n\n* ``file_name``: The name of the ONNX file to load. If not specified, will default to ``\"openvino_model.xml\"`` or otherwise ``\"openvino/openvino_model.xml\"``. This argument is useful for specifying optimized or quantized models.\n* ``export``: A boolean flag specifying whether the model will be exported. If not provided, ``export`` will be set to ``True`` if the model repository or directory does not already contain an OpenVINO model.\n\n.. tip::\n\n It's heavily recommended to save the exported model to prevent having to re-export it every time you run your code. You can do this by calling :meth:`model.save_pretrained() torch-fp32: PyTorch with float32 precision (default).\n torch-fp16: PyTorch with float16 precision, via model_kwargs={\"torch_dtype\": \"float16\"}.\n torch-bf16: PyTorch with bfloat16 precision, via model_kwargs={\"torch_dtype\": \"bfloat16\"}.\n onnx: ONNX with float32 precision, via backend=\"onnx\".\n onnx-O1: ONNX with float32 precision and O1 optimization, via export_optimized_onnx_model(..., optimization_config=\"O1\", ...) and backend=\"onnx\".\n onnx-O2: ONNX with float32 precision and O2 optimization, via export_optimized_onnx_model(..., optimization_config=\"O2\", ...) and backend=\"onnx\".\n onnx-O3: ONNX with float32 precision and O3 optimization, via export_optimized_onnx_model(..., optimization_config=\"O3\", ...) and backend=\"onnx\".\n onnx-O4: ONNX with float16 precision and O4 optimization, via export_optimized_onnx_model(..., optimization_config=\"O4\", ...) and backend=\"onnx\".\n onnx-qint8: ONNX quantized to int8 with \"avx512_vnni\", via export_dynamic_quantized_onnx_model(..., quantization_config=\"avx512_vnni\", ...) and backend=\"onnx\". The different quantization configurations resulted in roughly equivalent speedups.\n openvino: OpenVINO, via backend=\"openvino\".\n openvino-qint8: OpenVINO quantized to int8 via export_static_quantized_openvino_model(..., quantization_config=OVQuantizationConfig(), ...) and backend=\"openvino\".\n ![\"CrossEncoder](\"https://raw.githubusercontent.com/huggingface/sentence-transformers/main/docs/img/CrossEncoder.png\")
\n\n```{eval-rst}\nFor each question pair, we pass question A and question B through the BERT-based model, after which a classifier head converts the intermediary representation from the BERT-based model into a similarity score. With this loss, we apply :class:`torch.nn.BCEWithLogitsLoss` which accepts logits (a.k.a. outputs, raw predictions) and gold similarity scores (1 if duplicate, 0 if not duplicate) to compute a loss denoting how well the model has done. This loss is then minimized to improve the performance of the model.\n```\n\n## Inference\n\nYou can perform inference using any of the [pre-trained CrossEncoder models for Duplicate Question detection](../../../../docs/cross_encoder/pretrained_models.md#quora-duplicate-questions) like so:\n\n```python\nfrom sentence_transformers import CrossEncoder\n\nmodel = CrossEncoder('cross-encoder/quora-distilroberta-base')\nscores = model.predict([\n ('What do apples consist of?', 'What are in Apple devices?'),\n ('How do I get good at programming?', 'How to become a good programmer?')\n])\nprint(scores)\n# [0.00056, 0.97536]\n```\n"
},
{
"path": "examples/cross_encoder/training/quora_duplicate_questions/training_quora_duplicate_questions.py",
"content": "\"\"\"\nThis examples trains a CrossEncoder for the Quora Duplicate Questions Detection task. A CrossEncoder takes a sentence pair\nas input and outputs a label. Here, it output a continuous labels 0...1 to indicate the similarity between the input pair.\n\nIt does NOT produce a sentence embedding and does NOT work for individual sentences.\n\nUsage:\npython training_quora_duplicate_questions.py\n\n\"\"\"\n\nimport logging\nimport traceback\nfrom datetime import datetime\n\nfrom datasets import load_dataset\n\nfrom sentence_transformers.cross_encoder import CrossEncoder, CrossEncoderTrainingArguments\nfrom sentence_transformers.cross_encoder.evaluation import CrossEncoderClassificationEvaluator\nfrom sentence_transformers.cross_encoder.losses import BinaryCrossEntropyLoss\nfrom sentence_transformers.cross_encoder.trainer import CrossEncoderTrainer\n\n# Set the log level to INFO to get more information\nlogging.basicConfig(format=\"%(asctime)s - %(message)s\", datefmt=\"%Y-%m-%d %H:%M:%S\", level=logging.INFO)\n\ntrain_batch_size = 64\nnum_epochs = 1\noutput_dir = \"output/training_ce_quora-\" + datetime.now().strftime(\"%Y-%m-%d_%H-%M-%S\")\n\n# 1. Define our CrossEncoder model. We use distilroberta-base as the base model and set it up to predict 1 label\n# You can also use other base models, like bert-base-uncased, microsoft/mpnet-base, or rerankers like Alibaba-NLP/gte-reranker-modernbert-base\nmodel_name = \"distilroberta-base\"\nmodel = CrossEncoder(model_name, num_labels=1)\n\n# 2. Load the Quora duplicates dataset: https://huggingface.co/datasets/sentence-transformers/quora-duplicates\nlogging.info(\"Read quora-duplicates train dataset\")\ndataset = load_dataset(\"sentence-transformers/quora-duplicates\", \"pair-class\", split=\"train\")\neval_dataset = dataset.select(range(10_000))\ntest_dataset = dataset.select(range(10_000, 20_000))\ntrain_dataset = dataset.select(range(20_000, len(dataset)))\nlogging.info(train_dataset)\nlogging.info(eval_dataset)\nlogging.info(test_dataset)\n\n# 3. Define our training loss, we use one that accepts pairs with a binary label\nloss = BinaryCrossEntropyLoss(model)\n\n# 4. Before and during training, we use CrossEncoderClassificationEvaluator to measure the performance on the dev set\ndev_cls_evaluator = CrossEncoderClassificationEvaluator(\n sentence_pairs=list(zip(eval_dataset[\"sentence1\"], eval_dataset[\"sentence2\"])),\n labels=eval_dataset[\"label\"],\n name=\"quora-duplicates-dev\",\n)\ndev_cls_evaluator(model)\n\n# 5. Define the training arguments\nshort_model_name = model_name if \"/\" not in model_name else model_name.split(\"/\")[-1]\nrun_name = f\"reranker-{short_model_name}-quora-duplicates\"\nargs = CrossEncoderTrainingArguments(\n # Required parameter:\n output_dir=output_dir,\n # Optional training parameters:\n num_train_epochs=num_epochs,\n per_device_train_batch_size=train_batch_size,\n per_device_eval_batch_size=train_batch_size,\n warmup_ratio=0.1,\n fp16=False, # Set to False if you get an error that your GPU can't run on FP16\n bf16=True, # Set to True if you have a GPU that supports BF16\n # Optional tracking/debugging parameters:\n eval_strategy=\"steps\",\n eval_steps=500,\n save_strategy=\"steps\",\n save_steps=500,\n save_total_limit=2,\n logging_steps=100,\n run_name=run_name, # Will be used in W&B if `wandb` is installed\n)\n\n# 6. Create the trainer & start training\ntrainer = CrossEncoderTrainer(\n model=model,\n args=args,\n train_dataset=train_dataset,\n eval_dataset=eval_dataset,\n loss=loss,\n evaluator=dev_cls_evaluator,\n)\ntrainer.train()\n\n# 7. Evaluate the final model on test dataset\ntest_cls_evaluator = CrossEncoderClassificationEvaluator(\n sentence_pairs=list(zip(eval_dataset[\"sentence1\"], eval_dataset[\"sentence2\"])),\n labels=eval_dataset[\"label\"],\n name=\"quora-duplicates-test\",\n)\ntest_cls_evaluator(model)\n\n# 8. Save the final model\nfinal_output_dir = f\"{output_dir}/final\"\nmodel.save_pretrained(final_output_dir)\n\n# 9. (Optional) save the model to the Hugging Face Hub!\n# It is recommended to run `huggingface-cli login` to log into your Hugging Face account first\ntry:\n model.push_to_hub(run_name)\nexcept Exception:\n logging.error(\n f\"Error uploading model to the Hugging Face Hub:\\n{traceback.format_exc()}To upload it manually, you can run \"\n f\"`huggingface-cli login`, followed by loading the model using `model = CrossEncoder({final_output_dir!r})` \"\n f\"and saving it using `model.push_to_hub('{run_name}')`.\"\n )\n"
},
{
"path": "examples/cross_encoder/training/rerankers/README.md",
"content": "# Rerankers\n\n```{eval-rst}\nReranker models are often :class:`~sentence_transformers.cross_encoder.CrossEncoder` models with 1 output class, i.e. given a pair of texts (query, answer), the model outputs one score. This score, either a float score that reasonably ranges between -10.0 and 10.0, or a score that's bound to 0...1, denotes to what extent the answer can help answer the query.\n\nMany reranker models are trained on MS MARCO:\n\n- `MS MARCO Pre-trained Cross Encoders <../../../../docs/cross_encoder/pretrained_models.html#ms-marco>`_\n- `Cross Encoder > Training Examples > MS MARCO <../ms_marco/README.html>`_\n```\n\nBut most likely, you will get the best results when training on your dataset. Because of this, this page includes some examples training scripts that you can adopt for your own data:\n\n- **[training_gooaq_bce.py](training_gooaq_bce.py)**:\n ```{eval-rst}\n This example uses :class:`~sentence_transformers.cross_encoder.losses.BinaryCrossEntropyLoss` on labeled pair data that was mined from the `GooAQ \n\n```{eval-rst}\nFor each sentence pair, we pass sentence A and sentence B through the BERT-based model, after which a classifier head converts the intermediary representation from the BERT-based model into a similarity score. With this loss, we apply :class:`torch.nn.BCEWithLogitsLoss` which accepts logits (a.k.a. outputs, raw predictions) and gold similarity scores to compute a loss denoting how well the model has done on this batch. This loss can be minimized to improve the performance of the model.\n```\n\n## Inference\n\nYou can perform inference using any of the [pre-trained CrossEncoder models for STS](../../../../docs/cross_encoder/pretrained_models.md#stsbenchmark) like so:\n\n```python\nfrom sentence_transformers import CrossEncoder\n\nmodel = CrossEncoder(\"cross-encoder/stsb-roberta-base\")\nscores = model.predict([(\"It's a wonderful day outside.\", \"It's so sunny today!\"), (\"It's a wonderful day outside.\", \"He drove to work earlier.\")])\n# => array([0.60443085, 0.00240758], dtype=float32)\n```\n"
},
{
"path": "examples/cross_encoder/training/sts/training_stsbenchmark.py",
"content": "\"\"\"\nThis examples trains a CrossEncoder for the STSbenchmark task. A CrossEncoder takes a sentence pair\nas input and outputs a label. Here, it output a continuous labels 0...1 to indicate the similarity between the input pair.\n\nIt does NOT produce a sentence embedding and does NOT work for individual sentences.\n\nUsage:\npython training_stsbenchmark.py\n\"\"\"\n\nimport logging\nimport traceback\nfrom datetime import datetime\n\nfrom datasets import load_dataset\n\nfrom sentence_transformers.cross_encoder import CrossEncoder\nfrom sentence_transformers.cross_encoder.evaluation import CrossEncoderCorrelationEvaluator\nfrom sentence_transformers.cross_encoder.losses.BinaryCrossEntropyLoss import BinaryCrossEntropyLoss\nfrom sentence_transformers.cross_encoder.trainer import CrossEncoderTrainer\nfrom sentence_transformers.cross_encoder.training_args import CrossEncoderTrainingArguments\n\n# Set the log level to INFO to get more information\nlogging.basicConfig(format=\"%(asctime)s - %(message)s\", datefmt=\"%Y-%m-%d %H:%M:%S\", level=logging.INFO)\n\ntrain_batch_size = 64\nnum_epochs = 4\noutput_dir = \"output/training_ce_stsbenchmark-\" + datetime.now().strftime(\"%Y-%m-%d_%H-%M-%S\")\n\n# 1. Define our CrossEncoder model. We use distilroberta-base as the base model and set it up to predict 1 label\n# You can also use other base models, like bert-base-uncased, microsoft/mpnet-base, or rerankers like Alibaba-NLP/gte-reranker-modernbert-base\nmodel_name = \"distilroberta-base\"\nmodel = CrossEncoder(model_name, num_labels=1)\n\n# 2. Load the STSB dataset: https://huggingface.co/datasets/sentence-transformers/stsb\ntrain_dataset = load_dataset(\"sentence-transformers/stsb\", split=\"train\")\neval_dataset = load_dataset(\"sentence-transformers/stsb\", split=\"validation\")\ntest_dataset = load_dataset(\"sentence-transformers/stsb\", split=\"test\")\nlogging.info(train_dataset)\n\n# 3. Define our training loss, we use one that accepts pairs with a binary label\nloss = BinaryCrossEntropyLoss(model)\n\n# 4. Before and during training, we use CrossEncoderClassificationEvaluator to measure the performance on the dev set\neval_evaluator = CrossEncoderCorrelationEvaluator(\n sentence_pairs=list(zip(eval_dataset[\"sentence1\"], eval_dataset[\"sentence2\"])),\n scores=eval_dataset[\"score\"],\n name=\"stsb-validation\",\n)\neval_evaluator(model)\n\n# 5. Define the training arguments\nshort_model_name = model_name if \"/\" not in model_name else model_name.split(\"/\")[-1]\nrun_name = f\"reranker-{short_model_name}-stsb\"\nargs = CrossEncoderTrainingArguments(\n # Required parameter:\n output_dir=output_dir,\n # Optional training parameters:\n num_train_epochs=num_epochs,\n per_device_train_batch_size=train_batch_size,\n per_device_eval_batch_size=train_batch_size,\n warmup_ratio=0.1,\n fp16=False, # Set to False if you get an error that your GPU can't run on FP16\n bf16=True, # Set to True if you have a GPU that supports BF16\n # Optional tracking/debugging parameters:\n eval_strategy=\"steps\",\n eval_steps=80,\n save_strategy=\"steps\",\n save_steps=80,\n save_total_limit=2,\n logging_steps=20,\n run_name=run_name, # Will be used in W&B if `wandb` is installed\n)\n\n# 6. Create the trainer & start training\ntrainer = CrossEncoderTrainer(\n model=model,\n args=args,\n train_dataset=train_dataset,\n eval_dataset=eval_dataset,\n loss=loss,\n evaluator=eval_evaluator,\n)\ntrainer.train()\n\n# 7. Evaluate the final model on test dataset\ntest_evaluator = CrossEncoderCorrelationEvaluator(\n sentence_pairs=list(zip(test_dataset[\"sentence1\"], test_dataset[\"sentence2\"])),\n scores=test_dataset[\"score\"],\n name=\"stsb-test\",\n)\ntest_evaluator(model)\n\n# 8. Save the final model\nfinal_output_dir = f\"{output_dir}/final\"\nmodel.save_pretrained(final_output_dir)\n\n# 9. (Optional) save the model to the Hugging Face Hub!\n# It is recommended to run `huggingface-cli login` to log into your Hugging Face account first\ntry:\n model.push_to_hub(run_name)\nexcept Exception:\n logging.error(\n f\"Error uploading model to the Hugging Face Hub:\\n{traceback.format_exc()}To upload it manually, you can run \"\n f\"`huggingface-cli login`, followed by loading the model using `model = CrossEncoder({final_output_dir!r})` \"\n f\"and saving it using `model.push_to_hub('{run_name}')`.\"\n )\n"
},
{
"path": "examples/sentence_transformer/README.md",
"content": "# Examples\n\nThis folder contains various examples how to use SentenceTransformers.\n\n## Applications\n\nThe [applications](applications/) folder contains examples how to use SentenceTransformers for tasks like clustering or semantic search.\n\n## Evaluation\n\nThe [evaluation](evaluation/) folder contains some examples how to evaluate SentenceTransformer models for common tasks.\n\n## Training\n\nThe [training](training/) folder contains examples how to fine-tune transformer models like BERT, RoBERTa, or XLM-RoBERTa for generating sentence embedding. For the documentation how to train your own models, see [Training Overview](http://www.sbert.net/docs/sentence_transformer/training_overview.html).\n\n## Unsupervised Learning\n\nThe [unsupervised_learning](unsupervised_learning/) folder contains examples how to train sentence embedding models without labeled data.\n"
},
{
"path": "examples/sentence_transformer/applications/README.md",
"content": "# Applications\n\nSentenceTransformers can be used for various use-cases. In these folders, you find several example scripts that show case how SentenceTransformers can be used\n\n## Computing Embeddings\n\nThe [computing-embeddings](computing-embeddings/) folder contains examples how to compute sentence embeddings using SentenceTransformers.\n\n## Clustering\n\nThe [clustering](clustering/) folder shows how SentenceTransformers can be used for text clustering, i.e., grouping sentences together based on their similarity.\n\n## Cross-Encoder\n\nSentenceTransformers also support training and inference of [Cross-Encoders](cross-encoder/). There, two sentences are presented simultaneously to the transformer network and a score (0...1) is derived indicating the similarity or a label.\n\n## Parallel Sentence Mining\n\nThe [parallel-sentence-mining](parallel-sentence-mining/) folder contains examples of how parallel (translated) sentences can be found in two corpora of different languages. For example, you take the English and the Spanish Wikipedia and the script finds and returns all translated English-Spanish sentence pairs.\n\n## Paraphrase Mining\n\nThe [paraphrase-mining](paraphrase-mining/) folder contains examples to find all paraphrase sentences in a large set of sentences. The example can be used to find e.g. duplicate questions or duplicate sentences in a set of Millions of questions / sentences.\n\n## Semantic Search\n\nThe [semantic-search](semantic-search/) folder shows examples for semantic search: Given a sentence, find in a large collection semantically similar sentences.\n\n## Retrieve & Rerank\n\nThe [retrieve_rerank](retrieve_rerank/) folder shows how to combine a bi-encoder for semantic search retrieval and a more powerful re-ranking stage with a cross-encoder.\n\n## Image Search\n\nThe [image-search](image-search/) folder shows how to use the image&text-models, which can map images and text to the same vector space. This allows for an image search given a user query.\n\n## Text Summarization\n\nThe [text-summarization](text-summarization/) folder shows how SentenceTransformers can be used for extractive summarization: Give a long document, find the k sentences that give a good and short summary of the content.\n"
},
{
"path": "examples/sentence_transformer/applications/clustering/README.md",
"content": "# Clustering\n\nSentence-Transformers can be used in different ways to perform clustering of small or large set of sentences.\n\n## k-Means\n\n[kmeans.py](kmeans.py) contains an example of using [K-means Clustering Algorithm](https://scikit-learn.org/stable/modules/clustering.html#k-means). K-Means requires that the number of clusters is specified beforehand. The sentences are clustered in groups of about equal size.\n\n## Agglomerative Clustering\n\n[agglomerative.py](agglomerative.py) shows an example of using [Hierarchical clustering](https://scikit-learn.org/stable/modules/clustering.html#hierarchical-clustering) using the [Agglomerative Clustering Algorithm](https://scikit-learn.org/stable/modules/generated/sklearn.cluster.AgglomerativeClustering.html#sklearn.cluster.AgglomerativeClustering). In contrast to k-means, we can specify a threshold for the clustering: Clusters below that threshold are merged. This algorithm can be useful if the number of clusters is unknown. By the threshold, we can control if we want to have many small and fine-grained clusters or few coarse-grained clusters.\n\n## Fast Clustering\n\nAgglomerative Clustering for larger datasets is quite slow, so it is only applicable for maybe a few thousand sentences.\n\nIn [fast_clustering.py](fast_clustering.py) we present a clustering algorithm that is tuned for large datasets (50k sentences in less than 5 seconds). In a large list of sentences it searches for local communities: A local community is a set of highly similar sentences.\n\nYou can configure the threshold of cosine-similarity for which we consider two sentences as similar. Also, you can specify the minimal size for a local community. This allows you to get either large coarse-grained clusters or small fine-grained clusters.\n\nWe apply it on the [Quora Duplicate Questions](https://huggingface.co/datasets/sentence-transformers/quora-duplicates) dataset and the output looks something like this:\n\n```\nCluster 1, #83 Elements\n What should I do to improve my English ?\n What should I do to improve my spoken English?\n Can I improve my English?\n ...\n\nCluster 2, #79 Elements\n How can I earn money online?\n How do I earn money online?\n Can I earn money online?\n ...\n \n...\n\nCluster 47, #25 Elements\n What are some mind-blowing Mobile gadgets that exist that most people don't know about?\n What are some mind-blowing gadgets and technologies that exist that most people don't know about?\n What are some mind-blowing mobile technology tools that exist that most people don't know about?\n ...\n```\n\n## Topic Modeling\n\nTopic modeling is the process of discovering topics in a collection of documents.\n\nAn example is shown in the following picture, which shows the identified topics in the 20 newsgroup dataset:\n\n\n\nFor each topic, you want to extract the words that describe this topic:\n\n\n\nSentence-Transformers can be used to identify these topics in a collection of sentences, paragraphs or short documents. For an excellent tutorial, see [Topic Modeling with BERT](https://medium.com/data-science/topic-modeling-with-bert-779f7db187e6) as well as the [BERTopic](https://github.com/MaartenGr/BERTopic) and [Top2Vec](https://github.com/ddangelov/Top2Vec) repositories.\n\nImage source: [Top2Vec: Distributed Representations of Topics](https://huggingface.co/papers/2008.09470)\n"
},
{
"path": "examples/sentence_transformer/applications/clustering/agglomerative.py",
"content": "\"\"\"\nThis is a simple application for sentence embeddings: clustering\n\nSentences are mapped to sentence embeddings and then agglomerative clustering with a threshold is applied.\n\"\"\"\n\nfrom sklearn.cluster import AgglomerativeClustering\n\nfrom sentence_transformers import SentenceTransformer\n\nembedder = SentenceTransformer(\"all-MiniLM-L6-v2\")\n\n# Corpus with example sentences\ncorpus = [\n \"A man is eating food.\",\n \"A man is eating a piece of bread.\",\n \"A man is eating pasta.\",\n \"The girl is carrying a baby.\",\n \"The baby is carried by the woman\",\n \"A man is riding a horse.\",\n \"A man is riding a white horse on an enclosed ground.\",\n \"A monkey is playing drums.\",\n \"Someone in a gorilla costume is playing a set of drums.\",\n \"A cheetah is running behind its prey.\",\n \"A cheetah chases prey on across a field.\",\n]\ncorpus_embeddings = embedder.encode(corpus)\n\n# Some models don't automatically normalize the embeddings, in which case you should normalize the embeddings:\n# corpus_embeddings = corpus_embeddings / np.linalg.norm(corpus_embeddings, axis=1, keepdims=True)\n\n# Perform agglomerative clustering\nclustering_model = AgglomerativeClustering(\n n_clusters=None, distance_threshold=1.5\n) # , affinity='cosine', linkage='average', distance_threshold=0.4)\nclustering_model.fit(corpus_embeddings)\ncluster_assignment = clustering_model.labels_\n\nclustered_sentences = {}\nfor sentence_id, cluster_id in enumerate(cluster_assignment):\n if cluster_id not in clustered_sentences:\n clustered_sentences[cluster_id] = []\n\n clustered_sentences[cluster_id].append(corpus[sentence_id])\n\nfor i, cluster in clustered_sentences.items():\n print(\"Cluster \", i + 1)\n print(cluster)\n print(\"\")\n"
},
{
"path": "examples/sentence_transformer/applications/clustering/fast_clustering.py",
"content": "\"\"\"\nThis is a more complex example on performing clustering on large scale dataset.\n\nThis examples find in a large set of sentences local communities, i.e., groups of sentences that are highly\nsimilar. You can freely configure the threshold what is considered as similar. A high threshold will\nonly find extremely similar sentences, a lower threshold will find more sentence that are less similar.\n\nA second parameter is 'min_community_size': Only communities with at least a certain number of sentences will be returned.\n\nThe method for finding the communities is extremely fast, for clustering 50k sentences it requires only 5 seconds (plus embedding computation).\n\nIn this example, we download a large set of questions from Quora and then find similar questions in this set.\n\"\"\"\n\nimport csv\nimport os\nimport time\n\nfrom sentence_transformers import SentenceTransformer, util\n\n# Model for computing sentence embeddings. We use one trained for similar questions detection\nmodel = SentenceTransformer(\"all-MiniLM-L6-v2\")\n\n# We download the Quora Duplicate Questions Dataset (https://www.quora.com/q/quoradata/First-Quora-Dataset-Release-Question-Pairs)\n# and find similar question in it\nurl = \"http://qim.fs.quoracdn.net/quora_duplicate_questions.tsv\"\ndataset_path = \"quora_duplicate_questions.tsv\"\nmax_corpus_size = 50000 # We limit our corpus to only the first 50k questions\n\n\n# Check if the dataset exists. If not, download and extract\n# Download dataset if needed\nif not os.path.exists(dataset_path):\n print(\"Download dataset\")\n util.http_get(url, dataset_path)\n\n# Get all unique sentences from the file\ncorpus_sentences = set()\nwith open(dataset_path, encoding=\"utf8\") as fIn:\n reader = csv.DictReader(fIn, delimiter=\"\\t\", quoting=csv.QUOTE_MINIMAL)\n for row in reader:\n corpus_sentences.add(row[\"question1\"])\n corpus_sentences.add(row[\"question2\"])\n if len(corpus_sentences) >= max_corpus_size:\n break\n\ncorpus_sentences = list(corpus_sentences)\nprint(\"Encode the corpus. This might take a while\")\ncorpus_embeddings = model.encode(corpus_sentences, batch_size=64, show_progress_bar=True, convert_to_tensor=True)\n\n\nprint(\"Start clustering\")\nstart_time = time.time()\n\n# Two parameters to tune:\n# min_cluster_size: Only consider cluster that have at least 25 elements\n# threshold: Consider sentence pairs with a cosine-similarity larger than threshold as similar\nclusters = util.community_detection(corpus_embeddings, min_community_size=25, threshold=0.75)\n\nprint(f\"Clustering done after {time.time() - start_time:.2f} sec\")\n\n# Print for all clusters the top 3 and bottom 3 elements\nfor i, cluster in enumerate(clusters):\n print(f\"\\nCluster {i + 1}, #{len(cluster)} Elements \")\n for sentence_id in cluster[0:3]:\n print(\"\\t\", corpus_sentences[sentence_id])\n print(\"\\t\", \"...\")\n for sentence_id in cluster[-3:]:\n print(\"\\t\", corpus_sentences[sentence_id])\n"
},
{
"path": "examples/sentence_transformer/applications/clustering/kmeans.py",
"content": "\"\"\"\nThis is a simple application for sentence embeddings: clustering\n\nSentences are mapped to sentence embeddings and then k-mean clustering is applied.\n\"\"\"\n\nfrom sklearn.cluster import KMeans\n\nfrom sentence_transformers import SentenceTransformer\n\nembedder = SentenceTransformer(\"all-MiniLM-L6-v2\")\n\n# Corpus with example sentences\ncorpus = [\n \"A man is eating food.\",\n \"A man is eating a piece of bread.\",\n \"A man is eating pasta.\",\n \"The girl is carrying a baby.\",\n \"The baby is carried by the woman\",\n \"A man is riding a horse.\",\n \"A man is riding a white horse on an enclosed ground.\",\n \"A monkey is playing drums.\",\n \"Someone in a gorilla costume is playing a set of drums.\",\n \"A cheetah is running behind its prey.\",\n \"A cheetah chases prey on across a field.\",\n]\ncorpus_embeddings = embedder.encode(corpus)\n\n# Perform kmean clustering\nnum_clusters = 5\nclustering_model = KMeans(n_clusters=num_clusters)\nclustering_model.fit(corpus_embeddings)\ncluster_assignment = clustering_model.labels_\n\nclustered_sentences = [[] for i in range(num_clusters)]\nfor sentence_id, cluster_id in enumerate(cluster_assignment):\n clustered_sentences[cluster_id].append(corpus[sentence_id])\n\nfor i, cluster in enumerate(clustered_sentences):\n print(\"Cluster \", i + 1)\n print(cluster)\n print(\"\")\n"
},
{
"path": "examples/sentence_transformer/applications/computing-embeddings/README.rst",
"content": "Computing Embeddings\n====================\n\nOnce you have `installed <../../../../docs/installation.html>`_ Sentence Transformers, you can easily use Sentence Transformer models:\n\n.. sidebar:: Documentation\n\n 1. :class:`SentenceTransformer