Upload 15 files

1_Pooling/config.json

@@ -0,0 +1,7 @@
+{
+  "word_embedding_dimension": 384,
+  "pooling_mode_cls_token": false,
+  "pooling_mode_mean_tokens": true,
+  "pooling_mode_max_tokens": false,
+  "pooling_mode_mean_sqrt_len_tokens": false
+}

README.md

@@ -0,0 +1,249 @@
+---
+pipeline_tag: sentence-similarity
+tags:
+- sentence-transformers
+- feature-extraction
+- sentence-similarity
+datasets:
+- flax-sentence-embeddings/stackexchange_xml
+- ms_marco
+- gooaq
+- yahoo_answers_topics
+- search_qa
+- eli5
+- natural_questions
+- trivia_qa
+- embedding-data/QQP
+- embedding-data/PAQ_pairs
+- embedding-data/Amazon-QA
+- embedding-data/WikiAnswers
+---
+
+# multi-qa-MiniLM-distill-onnx-L6-cos-v1
+This is a [sentence-transformers](https://www.SBERT.net) model: It maps sentences & paragraphs to a 384 dimensional dense vector space and was designed for **semantic search**. It has been trained on 215M (question, answer) pairs from diverse sources. 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/multi-qa-MiniLM-L6-cos-v1')
+
+#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
+for doc, score in doc_score_pairs:
+    print(score, doc)
+```
+
+
+## PyTorch 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
+import torch.nn.functional as F
+
+#Mean Pooling - Take average of all tokens
+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'])
+
+    # Normalize embeddings
+    embeddings = F.normalize(embeddings, p=2, dim=1)
+	
+    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/multi-qa-MiniLM-L6-cos-v1")
+model = AutoModel.from_pretrained("sentence-transformers/multi-qa-MiniLM-L6-cos-v1")
+
+#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
+for doc, score in doc_score_pairs:
+    print(score, doc)
+```
+
+## TensorFlow Usage (HuggingFace Transformers)
+Similarly to the PyTorch example above, to use the model with TensorFlow 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, TFAutoModel
+import tensorflow as tf
+
+#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 = tf.cast(tf.tile(tf.expand_dims(attention_mask, -1), [1, 1, token_embeddings.shape[-1]]), tf.float32)
+    return tf.math.reduce_sum(token_embeddings * input_mask_expanded, 1) / tf.math.maximum(tf.math.reduce_sum(input_mask_expanded, 1), 1e-9)
+
+
+#Encode text
+def encode(texts):
+    # Tokenize sentences
+    encoded_input = tokenizer(texts, padding=True, truncation=True, return_tensors='tf')
+
+    # Compute token embeddings
+    model_output = model(**encoded_input, return_dict=True)
+
+    # Perform pooling
+    embeddings = mean_pooling(model_output, encoded_input['attention_mask'])
+
+    # Normalize embeddings
+    embeddings = tf.math.l2_normalize(embeddings, axis=1)
+
+    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/multi-qa-MiniLM-L6-cos-v1")
+model = TFAutoModel.from_pretrained("sentence-transformers/multi-qa-MiniLM-L6-cos-v1")
+
+#Encode query and docs
+query_emb = encode(query)
+doc_emb = encode(docs)
+
+#Compute dot score between query and all document embeddings
+scores = (query_emb @ tf.transpose(doc_emb))[0].numpy().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
+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 | 384 |
+| Produces normalized embeddings | Yes |
+| Pooling-Method | Mean pooling |
+| Suitable score functions | dot-product (`util.dot_score`), cosine-similarity (`util.cos_sim`), or euclidean distance |
+
+Note: When loaded with `sentence-transformers`, this model produces normalized embeddings with length 1. In that case, dot-product and cosine-similarity are equivalent. dot-product is preferred as it is faster. Euclidean distance is proportional to dot-product and can also be used.
+
+----
+
+
+## Background
+
+The project aims to train sentence embedding models on very large sentence level datasets using a self-supervised 
+contrastive learning objective. We use a contrastive learning objective: given a sentence from the pair, the model should predict which out of a set of randomly sampled other sentences, was actually paired with it in our dataset.
+
+We developped this model during the 
+[Community week using JAX/Flax for NLP & CV](https://discuss.huggingface.co/t/open-to-the-community-community-week-using-jax-flax-for-nlp-cv/7104), 
+organized by Hugging Face. We developped this model as part of the project:
+[Train the Best Sentence Embedding Model Ever with 1B Training Pairs](https://discuss.huggingface.co/t/train-the-best-sentence-embedding-model-ever-with-1b-training-pairs/7354). We benefited from efficient hardware infrastructure to run the project: 7 TPUs v3-8, as well as intervention from Googles Flax, JAX, and Cloud team member about efficient deep learning frameworks.
+
+## Intended uses
+
+Our model is intented to be used for semantic search: It encodes queries / questions and text paragraphs in a dense vector space. It finds relevant documents for the given passages.
+
+Note that there is a limit of 512 word pieces: Text longer than that will be truncated. Further note that the model was just trained on input text up to 250 word pieces. It might not work well for longer text. 
+
+
+
+## Training procedure
+
+The full training script is accessible in this current repository: `train_script.py`.
+
+### Pre-training 
+
+We use the pretrained [`nreimers/MiniLM-L6-H384-uncased`](https://huggingface.co/nreimers/MiniLM-L6-H384-uncased) model. Please refer to the model card for more detailed information about the pre-training procedure.
+
+#### Training
+
+We use the concatenation from multiple datasets to fine-tune our model. In total we have about 215M (question, answer) pairs.
+We sampled each dataset given a weighted probability which configuration is detailed in the `data_config.json` file.
+
+The model was trained with [MultipleNegativesRankingLoss](https://www.sbert.net/docs/package_reference/losses.html#multiplenegativesrankingloss) using Mean-pooling, cosine-similarity as similarity function, and a scale of 20.
+
+
+
+
+| Dataset                    | Number of training tuples  |
+|--------------------------------------------------------|:--------------------------:|
+| [WikiAnswers](https://github.com/afader/oqa#wikianswers-corpus) Duplicate question pairs from WikiAnswers |  77,427,422 |
+| [PAQ](https://github.com/facebookresearch/PAQ) Automatically generated (Question, Paragraph) pairs for each paragraph in Wikipedia | 64,371,441 |
+| [Stack Exchange](https://huggingface.co/datasets/flax-sentence-embeddings/stackexchange_xml) (Title, Body) pairs from all StackExchanges  | 25,316,456 |
+| [Stack Exchange](https://huggingface.co/datasets/flax-sentence-embeddings/stackexchange_xml) (Title, Answer) pairs from all StackExchanges  |  21,396,559 |
+| [MS MARCO](https://microsoft.github.io/msmarco/) Triplets (query, answer, hard_negative) for 500k queries from Bing search engine |  17,579,773 |
+| [GOOAQ: Open Question Answering with Diverse Answer Types](https://github.com/allenai/gooaq) (query, answer) pairs for 3M Google queries and Google featured snippet  | 3,012,496 |
+| [Amazon-QA](http://jmcauley.ucsd.edu/data/amazon/qa/) (Question, Answer) pairs from Amazon product pages | 2,448,839 
+| [Yahoo Answers](https://www.kaggle.com/soumikrakshit/yahoo-answers-dataset) (Title, Answer) pairs from Yahoo Answers | 1,198,260 |
+| [Yahoo Answers](https://www.kaggle.com/soumikrakshit/yahoo-answers-dataset) (Question, Answer) pairs from Yahoo Answers | 681,164 |
+| [Yahoo Answers](https://www.kaggle.com/soumikrakshit/yahoo-answers-dataset) (Title, Question) pairs from Yahoo Answers | 659,896 |
+| [SearchQA](https://huggingface.co/datasets/search_qa) (Question, Answer) pairs for 140k questions, each with Top5 Google snippets on that question | 582,261 |
+| [ELI5](https://huggingface.co/datasets/eli5) (Question, Answer) pairs from Reddit ELI5 (explainlikeimfive) | 325,475 |
+| [Stack Exchange](https://huggingface.co/datasets/flax-sentence-embeddings/stackexchange_xml) Duplicate questions pairs (titles) | 304,525 |
+| [Quora Question Triplets](https://quoradata.quora.com/First-Quora-Dataset-Release-Question-Pairs) (Question, Duplicate_Question, Hard_Negative) triplets for Quora Questions Pairs dataset | 103,663 |
+| [Natural Questions (NQ)](https://ai.google.com/research/NaturalQuestions) (Question, Paragraph) pairs for 100k real Google queries with relevant Wikipedia paragraph | 100,231 |
+| [SQuAD2.0](https://rajpurkar.github.io/SQuAD-explorer/) (Question, Paragraph) pairs from SQuAD2.0 dataset |  87,599 |
+| [TriviaQA](https://huggingface.co/datasets/trivia_qa) (Question, Evidence) pairs | 73,346 |
+| **Total** | **214,988,242** |

config.json

@@ -0,0 +1,25 @@
+{
+  "_name_or_path": "models/cos-v1-best",
+  "architectures": [
+    "BertModel"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "classifier_dropout": null,
+  "gradient_checkpointing": false,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 384,
+  "initializer_range": 0.02,
+  "intermediate_size": 1536,
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "bert",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 4,
+  "pad_token_id": 0,
+  "position_embedding_type": "absolute",
+  "transformers_version": "4.29.2",
+  "type_vocab_size": 2,
+  "use_cache": true,
+  "vocab_size": 30522
+}

config_sentence_transformers.json

@@ -0,0 +1,7 @@
+{
+  "__version__": {
+    "sentence_transformers": "2.0.0",
+    "transformers": "4.6.1",
+    "pytorch": "1.8.1"
+  }
+}

eval/mse_evaluation__results.csv

@@ -0,0 +1,30 @@
+epoch,steps,MSE
+0,5000,0.08164194878190756
+0,10000,0.06260087830014527
+0,15000,0.053438334725797176
+0,20000,0.04801056638825685
+0,25000,0.0445966434199363
+0,30000,0.04211385385133326
+0,35000,0.040131498826667666
+0,40000,0.03866856568492949
+0,45000,0.037445276393555105
+0,50000,0.03652568848337978
+0,55000,0.03562064084690064
+0,60000,0.03487043140921742
+0,65000,0.03426450421102345
+0,70000,0.03378996916580945
+0,75000,0.033300244831480086
+0,80000,0.032820276101119816
+0,85000,0.03252678434364498
+0,90000,0.032118355738930404
+0,95000,0.03190774004906416
+0,100000,0.031571456929668784
+0,105000,0.03135171136818826
+0,110000,0.031201684032566845
+0,115000,0.03108016971964389
+0,120000,0.030856009107083082
+0,125000,0.030771695310249925
+0,130000,0.03066081553697586
+0,135000,0.030605780193582177
+0,140000,0.030567956855520606
+0,-1,0.030567424255423248

eval/similarity_evaluation_sts-dev_results.csv

@@ -0,0 +1,30 @@
+epoch,steps,cosine_pearson,cosine_spearman,euclidean_pearson,euclidean_spearman,manhattan_pearson,manhattan_spearman,dot_pearson,dot_spearman
+0,5000,0.7451538219966819,0.7672554362824703,0.7663367711499433,0.7672554362824703,0.7656859380863119,0.7665947792435013,0.7451538231648414,0.7672554362824703
+0,10000,0.7537744166831953,0.7727486754280707,0.7728111123629107,0.7727486754280707,0.772113563269406,0.7721335168433461,0.7537744171689775,0.7727495539481395
+0,15000,0.7660933742804406,0.7837588700618559,0.7836123904512655,0.7837588700618559,0.7829209061843033,0.7830875130305814,0.7660933801320919,0.7837588693651809
+0,20000,0.7684300833864042,0.7855982699077577,0.785532933626244,0.7855982692094479,0.7845338039609955,0.7845750033796356,0.7684300882853332,0.7855982699077577
+0,25000,0.7707353950224363,0.7876847428779042,0.7876465143907596,0.7876847421777396,0.7867830462833947,0.7869706516377712,0.7707354006643212,0.7876847428779042
+0,30000,0.77288987781661,0.7890679662524103,0.7890394555299924,0.7890679655510161,0.788137743070403,0.7882666447140309,0.7728898769077066,0.7890677146611634
+0,35000,0.7714964043132171,0.7879360079865678,0.7881483073210547,0.7879371284726863,0.7872797682613883,0.7873248066864478,0.7714964114116738,0.7879371284726863
+0,40000,0.7738038431607456,0.7900336982355982,0.7900015695492877,0.7900336975333457,0.789036404739011,0.7893954248514412,0.7738038443211506,0.7900336982355982
+0,45000,0.7806805368603946,0.7953170748402448,0.7953952611135355,0.7953170748402448,0.794482786961417,0.7946208003390048,0.7806805365188378,0.795316296004493
+0,50000,0.7758800035273927,0.7920287779042389,0.7917483214037102,0.792028777200213,0.7907080715200523,0.791222195497074,0.7758800064681861,0.7920287779042389
+0,55000,0.7748974633837462,0.7907568393040405,0.7905916308754704,0.7907568386011451,0.7897169211995143,0.7899495391123526,0.7748974644641963,0.7907568393040405
+0,60000,0.7784748672436804,0.7939635781718496,0.793964252540622,0.7939635774661037,0.7929685054517607,0.7930615590508188,0.7784748678309645,0.7939635774661037
+0,65000,0.7796288427258389,0.7951236643816901,0.7950697460353463,0.7951236636749132,0.7942962171276358,0.7945430404989343,0.7796288448617663,0.7951236643816901
+0,70000,0.7796424798426436,0.7952969563162274,0.7948492536277543,0.7952969556092964,0.7939768644705751,0.7944538553840851,0.7796424862799302,0.7952978166371057
+0,75000,0.7769598727458167,0.7927814277048575,0.7922166093080583,0.7927823631288534,0.7915981847762255,0.7921869463483725,0.7769598789365952,0.7927814277048575
+0,80000,0.7774742857996642,0.7934620778257588,0.7931720059341743,0.7934620771204588,0.792433728896597,0.7927788061869001,0.7774742937530655,0.7934620778257588
+0,85000,0.7778284283777634,0.7933801275912681,0.7931055150588028,0.793380126886041,0.7923659661509699,0.7928011869852436,0.7778284197659264,0.7933805724314327
+0,90000,0.7778190920123474,0.7932520598872288,0.7927980747236021,0.7932520591821155,0.7919765295341479,0.7923518432591761,0.7778190862553716,0.7932520591821155
+0,95000,0.7795342361348376,0.7951428547863926,0.7947477485866722,0.7951428540795986,0.793933820785105,0.794293699396111,0.7795342378034608,0.7951415618979867
+0,100000,0.7811558920026177,0.7964721083727638,0.7959974871261926,0.7964721083727638,0.7953036438517008,0.7956409736399953,0.7811558906487714,0.7964721083727638
+0,105000,0.7789333814592223,0.7941989626759279,0.7937732318420716,0.7941989619699729,0.793105607100401,0.7936110345184971,0.7789333777991321,0.7941989626759279
+0,110000,0.7790156686608669,0.7944607101875235,0.7939863009721635,0.7944607094813357,0.7932901632304183,0.7937474314096579,0.7790156623433281,0.7944607094813357
+0,115000,0.7773604697868309,0.7928823123011013,0.7925392387219641,0.7928823123011013,0.7918524555529456,0.7924313931360675,0.7773604674828332,0.7928823115963166
+0,120000,0.7797444066117021,0.7954454544567308,0.7948229695790241,0.7954453169215147,0.7941276931152423,0.7945565785810856,0.779744398705051,0.7954454537496678
+0,125000,0.7794772857230747,0.7950229169812024,0.79449104446514,0.7950229169812024,0.7937674344847226,0.79436565603504,0.7794772873884481,0.7950229169812024
+0,130000,0.7802911181903579,0.7956809903890825,0.7951756431049894,0.7956809903890825,0.794476798728313,0.7950676316078248,0.7802911189881387,0.7956809903890825
+0,135000,0.7798078498424627,0.7951594686768616,0.7947034191959423,0.7951594679700529,0.7939996232677503,0.7945372807084875,0.7798078491935548,0.7951594686768616
+0,140000,0.7795179285289633,0.7949521909537459,0.7944688530241,0.7949521902471214,0.7937473834870582,0.7943429424962535,0.7795179357332032,0.7949521902471214
+0,-1,0.7795472646980206,0.7949874080599001,0.7944970293639978,0.7949874073532442,0.7937810593147978,0.7944118411202525,0.7795472601861694,0.7949874080599001

model.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:897920e276fe3222f214b4b4e2c57cd0165b0e999d0d0b67e086ac5eac58522f
+size 76059578

model_quantized.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:46453e4d5c32d5b0691bc353a62c60186f1db5dca3e89ff36b6e007519b8334a
+size 19161868

modules.json

@@ -0,0 +1,20 @@
+[
+  {
+    "idx": 0,
+    "name": "0",
+    "path": "",
+    "type": "sentence_transformers.models.Transformer"
+  },
+  {
+    "idx": 1,
+    "name": "1",
+    "path": "1_Pooling",
+    "type": "sentence_transformers.models.Pooling"
+  },
+  {
+    "idx": 2,
+    "name": "2",
+    "path": "2_Normalize",
+    "type": "sentence_transformers.models.Normalize"
+  }
+]

ort_config.json

@@ -0,0 +1,38 @@
+{
+  "one_external_file": true,
+  "opset": null,
+  "optimization": {
+    "disable_attention": null,
+    "disable_attention_fusion": false,
+    "disable_bias_gelu": null,
+    "disable_bias_gelu_fusion": false,
+    "disable_bias_skip_layer_norm": null,
+    "disable_bias_skip_layer_norm_fusion": false,
+    "disable_embed_layer_norm": true,
+    "disable_embed_layer_norm_fusion": true,
+    "disable_gelu": null,
+    "disable_gelu_fusion": false,
+    "disable_group_norm_fusion": true,
+    "disable_layer_norm": null,
+    "disable_layer_norm_fusion": false,
+    "disable_packed_kv": true,
+    "disable_shape_inference": false,
+    "disable_skip_layer_norm": null,
+    "disable_skip_layer_norm_fusion": false,
+    "enable_gelu_approximation": true,
+    "enable_gemm_fast_gelu_fusion": false,
+    "enable_transformers_specific_optimizations": true,
+    "fp16": false,
+    "no_attention_mask": false,
+    "optimization_level": 2,
+    "optimize_for_gpu": false,
+    "optimize_with_onnxruntime_only": null,
+    "use_mask_index": false,
+    "use_multi_head_attention": false,
+    "use_raw_attention_mask": false
+  },
+  "optimum_version": "1.8.7.dev0",
+  "quantization": {},
+  "transformers_version": "4.29.2",
+  "use_external_data_format": false
+}

sentence_bert_config.json

@@ -0,0 +1,4 @@
+{
+  "max_seq_length": 512,
+  "do_lower_case": false
+}

special_tokens_map.json

@@ -0,0 +1,7 @@
+{
+  "cls_token": "[CLS]",
+  "mask_token": "[MASK]",
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "unk_token": "[UNK]"
+}

tokenizer_config.json

@@ -0,0 +1,15 @@
+{
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "[CLS]",
+  "do_basic_tokenize": true,
+  "do_lower_case": true,
+  "mask_token": "[MASK]",
+  "model_max_length": 512,
+  "never_split": null,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizer",
+  "unk_token": "[UNK]"
+}