Update README.md

README.md

@@ -1,130 +1,157 @@
 ---
 pipeline_tag: sentence-similarity
+language: fr
+license: mit
+datasets:
+- unicamp-dl/mmarco
+metrics:
+- recall
 tags:
-- sentence-transformers
-- feature-extraction
-- sentence-similarity
-- transformers
-
+- passage-retrieval
+library_name: sentence-transformers
+base_model: microsoft/mdeberta-v3-base
+model-index:
+- name: biencoder-mdebertav3-mmarcoFR
+  results:
+    - task:
+        type: sentence-similarity
+        name: Passage Retrieval
+      dataset:
+        type: unicamp-dl/mmarco
+        name: mMARCO-fr
+        config: french
+        split: validation
+      metrics:
+        - type: recall_at_1000
+          name: Recall@1000
+          value: 87.04
+        - type: recall_at_500
+          name: Recall@500
+          value: 83.31
+        - type: recall_at_100
+          name: Recall@100
+          value: 71.44
+        - type: recall_at_10
+          name: Recall@10
+          value: 45.62
+        - type: map_at_10
+          name: MAP@10
+          value: 24.36
+        - type: ndcg_at_10
+          name: nDCG@10
+          value: 29.56
+        - type: mrr_at_10
+          name: MRR@10
+          value: 24.88
 ---
 
-# {MODEL_NAME}
-
-This is a [sentence-transformers](https://www.SBERT.net) model: It maps sentences & paragraphs to a 768 dimensional dense vector space and can be used for tasks like clustering or semantic search.
+# biencoder-mdebertav3-mmarcoFR
 
-<!--- Describe your model here -->
+This is a dense single-vector bi-encoder model for **French** that can be used for semantic search. The model maps queries and passages to 768-dimensional dense vectors which are used to compute relevance through cosine similarity.
 
-## Usage (Sentence-Transformers)
+## Usage
 
-Using this model becomes easy when you have [sentence-transformers](https://www.SBERT.net) installed:
+Here are some examples for using the model with [Sentence-Transformers](#using-sentence-transformers), [FlagEmbedding](#using-flagembedding), or [Huggingface Transformers](#using-huggingface-transformers).
 
-```
-pip install -U sentence-transformers
-```
+#### Using Sentence-Transformers
 
-Then you can use the model like this:
+Start by installing the [library](https://www.SBERT.net): `pip install -U sentence-transformers`. Then, you can use the model like this:
 
 ```python
 from sentence_transformers import SentenceTransformer
-sentences = ["This is an example sentence", "Each sentence is converted"]
 
-model = SentenceTransformer('{MODEL_NAME}')
-embeddings = model.encode(sentences)
-print(embeddings)
+queries = ["Ceci est un exemple de requête.", "Voici un second exemple."]
+passages = ["Ceci est un exemple de passage.", "Et voilà un deuxième exemple."]
+
+model = SentenceTransformer('antoinelouis/biencoder-mdebertav3-mmarcoFR')
+q_embeddings = model.encode(queries, normalize_embeddings=True)
+p_embeddings = model.encode(passages, normalize_embeddings=True)
+
+similarity = q_embeddings @ p_embeddings.T
+print(similarity)
 ```
 
+#### Using FlagEmbedding
+
+Start by installing the [library](https://github.com/FlagOpen/FlagEmbedding/): `pip install -U FlagEmbedding`. Then, you can use the model like this:
+
+```python
+from FlagEmbedding import FlagModel
+
+queries = ["Ceci est un exemple de requête.", "Voici un second exemple."]
+passages = ["Ceci est un exemple de passage.", "Et voilà un deuxième exemple."]
+
+model = FlagModel('antoinelouis/biencoder-mdebertav3-mmarcoFR')
+q_embeddings = model.encode(queries, normalize_embeddings=True)
+p_embeddings = model.encode(passages, normalize_embeddings=True)
+
+similarity = q_embeddings @ p_embeddings.T
+print(similarity)
+```
 
+#### Using Transformers
 
-## 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 right pooling-operation on-top of the contextualized word embeddings.
+Start by installing the [library](https://huggingface.co/docs/transformers): `pip install -U transformers`. Then, you can use the model like this:
 
 ```python
 from transformers import AutoTokenizer, AutoModel
-import torch
-
+from torch.nn.functional import normalize
 
-#Mean Pooling - Take attention mask into account for correct averaging
 def mean_pooling(model_output, attention_mask):
+    """ Perform mean pooling on-top of the contextualized word embeddings, while ignoring mask tokens in the mean computation."""
     token_embeddings = model_output[0] #First element of model_output contains all token embeddings
     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)
 
 
-# Sentences we want sentence embeddings for
-sentences = ['This is an example sentence', 'Each sentence is converted']
+queries = ["Ceci est un exemple de requête.", "Voici un second exemple."]
+passages = ["Ceci est un exemple de passage.", "Et voilà un deuxième exemple."]
 
-# Load model from HuggingFace Hub
-tokenizer = AutoTokenizer.from_pretrained('{MODEL_NAME}')
-model = AutoModel.from_pretrained('{MODEL_NAME}')
+tokenizer = AutoTokenizer.from_pretrained('antoinelouis/biencoder-mdebertav3-mmarcoFR')
+model = AutoModel.from_pretrained('antoinelouis/biencoder-mdebertav3-mmarcoFR')
 
-# Tokenize sentences
-encoded_input = tokenizer(sentences, padding=True, truncation=True, return_tensors='pt')
-
-# Compute token embeddings
+q_input = tokenizer(queries, padding=True, truncation=True, return_tensors='pt')
+p_input = tokenizer(passages, padding=True, truncation=True, return_tensors='pt')
 with torch.no_grad():
-    model_output = model(**encoded_input)
-
-# Perform pooling. In this case, mean pooling.
-sentence_embeddings = mean_pooling(model_output, encoded_input['attention_mask'])
-
-print("Sentence embeddings:")
-print(sentence_embeddings)
+    q_output = model(**encoded_queries)
+    p_output = model(**encoded_passages)
+q_embeddings = mean_pooling(q_output, q_input['attention_mask'])
+q_embedddings = normalize(q_embeddings, p=2, dim=1)
+p_embeddings = mean_pooling(p_output, p_input['attention_mask'])
+p_embedddings = normalize(p_embeddings, p=2, dim=1)
+
+similarity = q_embeddings @ p_embeddings.T
+print(similarity)
 ```
 
+## Evaluation
 
-
-## 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={MODEL_NAME})
-
+The model is evaluated on the smaller development set of [mMARCO-fr](https://ir-datasets.com/mmarco.html#mmarco/v2/fr/), which consists of 6,980 queries for a corpus of 
+8.8M candidate passages. We report the mean reciprocal rank (MRR), normalized discounted cumulative gainand (NDCG), mean average precision (MAP), and recall at various cut-offs (R@k).
+To see how it compares to other neural retrievers in French, check out the [*DécouvrIR*](https://huggingface.co/spaces/antoinelouis/decouvrir) leaderboard.
 
 ## Training
-The model was trained with the parameters:
-
-**DataLoader**:
-
-`torch.utils.data.dataloader.DataLoader` of length 3900 with parameters:
-```
-{'batch_size': 128, 'sampler': 'torch.utils.data.sampler.RandomSampler', 'batch_sampler': 'torch.utils.data.sampler.BatchSampler'}
-```
-
-**Loss**:
 
-`sentence_transformers.losses.MultipleNegativesRankingLoss.MultipleNegativesRankingLoss` with parameters:
-  ```
-  {'scale': 20.0, 'similarity_fct': 'cos_sim'}
-  ```
+#### Data
 
-Parameters of the fit()-Method:
-```
-{
-    "epochs": 20,
-    "evaluation_steps": 0,
-    "evaluator": "NoneType",
-    "max_grad_norm": 1,
-    "optimizer_class": "<class 'transformers.optimization.AdamW'>",
-    "optimizer_params": {
-        "lr": 2e-05,
-        "no_deprecation_warning": true
-    },
-    "scheduler": "warmuplinear",
-    "steps_per_epoch": null,
-    "warmup_steps": 7800,
-    "weight_decay": 0.01
-}
-```
+We use the French training samples from the [mMARCO](https://huggingface.co/datasets/unicamp-dl/mmarco) dataset, a multilingual machine-translated version of MS MARCO that contains 8.8M passages and 539K training queries. We do not employ the BM25 netaives provided by the official dataset but instead sample harder negatives mined from 12 distinct dense retrievers, using the [msmarco-hard-negatives](https://huggingface.co/datasets/sentence-transformers/msmarco-hard-negatives) distillation dataset.
 
+#### Implementation
 
-## Full Model Architecture
-```
-SentenceTransformerCustom(
-  (0): Transformer({'max_seq_length': 128, 'do_lower_case': False}) with Transformer model: DebertaV2Model 
-  (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})
-)
-```
+The model is initialized from the [microsoft/mdeberta-v3-base](https://huggingface.co/microsoft/mdeberta-v3-base) checkpoint and optimized via the cross-entropy loss 
+(as in [DPR](https://doi.org/10.48550/arXiv.2004.04906)) with a temperature of 0.05. It is fine-tuned on one 80GB NVIDIA H100 GPU for 20 epochs (i.e., 78k steps) 
+using the AdamW optimizer with a batch size of 128, a peak learning rate of 2e-5 with warm up along the first 7800 steps and linear scheduling. We set the maximum 
+sequence lengths for both the questions and passages to 128 tokens. We use the cosine similarity to compute relevance scores.
 
-## Citing & Authors
+## Citation
 
-<!--- Describe where people can find more information -->
+```bibtex
+@online{louis2024decouvrir,
+	author    = 'Antoine Louis',
+	title     = 'DécouvrIR: A Benchmark for Evaluating the Robustness of Information Retrieval Models in French',
+	publisher = 'Hugging Face',
+	month     = 'mar',
+	year      = '2024',
+	url       = 'https://huggingface.co/spaces/antoinelouis/decouvrir',
+}
+```