Update Sentence Transformers metadata (#2)

1acd072 verified 3 months ago

No virus

6.52 kB

	---
	language:
	- en
	license: apache-2.0
	library_name: sentence-transformers
	tags:
	- sentence-transformers
	- feature-extraction
	- sentence-similarity
	- transformers
	pipeline_tag: sentence-similarity
	---

	# msmarco-distilbert-dot-v5
	This is a [sentence-transformers](https://www.SBERT.net) model: It maps sentences & paragraphs to a 768 dimensional dense vector space and was designed for semantic search. It has been trained on 500K (query, answer) pairs from the [MS MARCO dataset](https://github.com/microsoft/MSMARCO-Passage-Ranking/). For an introduction to semantic search, have a look at: [SBERT.net - Semantic Search](https://www.sbert.net/examples/applications/semantic-search/README.html)


	## Usage (Sentence-Transformers)
	Using this model becomes easy when you have [sentence-transformers](https://www.SBERT.net) installed:

	```
	pip install -U sentence-transformers
	```

	Then you can use the model like this:
	```python
	from sentence_transformers import SentenceTransformer, util

	query = "How many people live in London?"
	docs = ["Around 9 Million people live in London", "London is known for its financial district"]

	#Load the model
	model = SentenceTransformer('sentence-transformers/msmarco-distilbert-dot-v5')

	#Encode query and documents
	query_emb = model.encode(query)
	doc_emb = model.encode(docs)

	#Compute dot score between query and all document embeddings
	scores = util.dot_score(query_emb, doc_emb)[0].cpu().tolist()

	#Combine docs & scores
	doc_score_pairs = list(zip(docs, scores))

	#Sort by decreasing score
	doc_score_pairs = sorted(doc_score_pairs, key=lambda x: x[1], reverse=True)

	#Output passages & scores
	print("Query:", query)
	for doc, score in doc_score_pairs:
	print(score, doc)
	```


	## Usage (HuggingFace Transformers)
	Without [sentence-transformers](https://www.SBERT.net), you can use the model like this: First, you pass your input through the transformer model, then you have to apply the correct pooling-operation on-top of the contextualized word embeddings.

	```python
	from transformers import AutoTokenizer, AutoModel
	import torch

	#Mean Pooling - Take attention mask into account for correct averaging
	def mean_pooling(model_output, attention_mask):
	token_embeddings = model_output.last_hidden_state
	input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
	return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)


	#Encode text
	def encode(texts):
	# Tokenize sentences
	encoded_input = tokenizer(texts, padding=True, truncation=True, return_tensors='pt')

	# Compute token embeddings
	with torch.no_grad():
	model_output = model(**encoded_input, return_dict=True)

	# Perform pooling
	embeddings = mean_pooling(model_output, encoded_input['attention_mask'])

	return embeddings


	# Sentences we want sentence embeddings for
	query = "How many people live in London?"
	docs = ["Around 9 Million people live in London", "London is known for its financial district"]

	# Load model from HuggingFace Hub
	tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/msmarco-distilbert-dot-v5")
	model = AutoModel.from_pretrained("sentence-transformers/msmarco-distilbert-dot-v5")

	#Encode query and docs
	query_emb = encode(query)
	doc_emb = encode(docs)

	#Compute dot score between query and all document embeddings
	scores = torch.mm(query_emb, doc_emb.transpose(0, 1))[0].cpu().tolist()

	#Combine docs & scores
	doc_score_pairs = list(zip(docs, scores))

	#Sort by decreasing score
	doc_score_pairs = sorted(doc_score_pairs, key=lambda x: x[1], reverse=True)

	#Output passages & scores
	print("Query:", query)
	for doc, score in doc_score_pairs:
	print(score, doc)
	```

	## Technical Details

	In the following some technical details how this model must be used:

	\| Setting \| Value \|
	\| --- \| :---: \|
	\| Dimensions \| 768 \|
	\| Max Sequence Length \| 512 \|
	\| Produces normalized embeddings \| No \|
	\| Pooling-Method \| Mean pooling \|
	\| Suitable score functions \| dot-product (e.g. `util.dot_score`) \|


	## Evaluation Results

	<!--- Describe how your model was evaluated -->

	For an automated evaluation of this model, see the Sentence Embeddings Benchmark: [https://seb.sbert.net](https://seb.sbert.net?model_name=msmarco-distilbert-base-dot-v5)


	## Training

	See `train_script.py` in this repository for the used training script.



	The model was trained with the parameters:

	DataLoader:

	`torch.utils.data.dataloader.DataLoader` of length 7858 with parameters:
	```
	{'batch_size': 64, 'sampler': 'torch.utils.data.sampler.RandomSampler', 'batch_sampler': 'torch.utils.data.sampler.BatchSampler'}
	```

	Loss:

	`sentence_transformers.losses.MarginMSELoss.MarginMSELoss`

	Parameters of the fit()-Method:
	```
	{
	"callback": null,
	"epochs": 30,
	"evaluation_steps": 0,
	"evaluator": "NoneType",
	"max_grad_norm": 1,
	"optimizer_class": "<class 'transformers.optimization.AdamW'>",
	"optimizer_params": {
	"lr": 1e-05
	},
	"scheduler": "WarmupLinear",
	"steps_per_epoch": null,
	"warmup_steps": 10000,
	"weight_decay": 0.01
	}
	```


	## Full Model Architecture
	```
	SentenceTransformer(
	(0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: DistilBertModel
	(1): Pooling({'word_embedding_dimension': 768, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False})
	)
	```

	## Citing & Authors

	This model was trained by [sentence-transformers](https://www.sbert.net/).

	If you find this model helpful, feel free to cite our publication [Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks](https://arxiv.org/abs/1908.10084):
	```bibtex
	@inproceedings{reimers-2019-sentence-bert,
	title = "Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks",
	author = "Reimers, Nils and Gurevych, Iryna",
	booktitle = "Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing",
	month = "11",
	year = "2019",
	publisher = "Association for Computational Linguistics",
	url = "http://arxiv.org/abs/1908.10084",
	}
	```

	## License

	This model is released under the Apache 2 license. However, note that this model was trained on the MS MARCO dataset which has it's own license restrictions: [MS MARCO - Terms and Conditions](https://github.com/microsoft/msmarco/blob/095515e8e28b756a62fcca7fcf1d8b3d9fbb96a9/README.md).