antoinelouis
/

dpr-xm

@@ -1,129 +1,255 @@
 ---
 pipeline_tag: sentence-similarity
 tags:
-- sentence-transformers
 - feature-extraction
 - sentence-similarity
-- transformers
 ---
-# {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.
-<!--- Describe your model here -->
-## 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
-sentences = ["This is an example sentence", "Each sentence is converted"]
-model = SentenceTransformer('{MODEL_NAME}')
-embeddings = model.encode(sentences)
-print(embeddings)
-```
-## 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.
 ```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[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']
-# Load model from HuggingFace Hub
-tokenizer = AutoTokenizer.from_pretrained('{MODEL_NAME}')
-model = AutoModel.from_pretrained('{MODEL_NAME}')
-# Tokenize sentences
-encoded_input = tokenizer(sentences, padding=True, truncation=True, return_tensors='pt')
-# Compute token embeddings
 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)
-```
-## 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})
 ## Training
-The model was trained with the parameters:
-**DataLoader**:
-`torch.utils.data.dataloader.DataLoader` of length 1950 with parameters:
-```
-{'batch_size': 256, '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'}
-  ```
-Parameters of the fit()-Method:
-```
-{
-    "epochs": 40,
-    "evaluation_steps": 0,
-    "evaluator": "NoneType",
-    "max_grad_norm": 1,
-    "optimizer_class": "<class 'torch.optim.adamw.AdamW'>",
-    "optimizer_params": {
-        "lr": 2e-05
-    },
-    "scheduler": "warmuplinear",
-    "steps_per_epoch": null,
-    "warmup_steps": 7800,
-    "weight_decay": 0.01
-}
-```
-## Full Model Architecture
-```
-SentenceTransformerCustom(
-  (0): Transformer({'max_seq_length': 128, 'do_lower_case': False}) with Transformer model: XmodModel
-  (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, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False})
-)
 ```
-## Citing & Authors
-<!--- Describe where people can find more information -->

 ---
 pipeline_tag: sentence-similarity
+language:
+- multilingual
+- af
+- am
+- ar
+- az
+- be
+- bg
+- bn
+- ca
+- cs
+- cy
+- da
+- de
+- el
+- en
+- eo
+- es
+- et
+- eu
+- fa
+- fi
+- fr
+- ga
+- gl
+- gu
+- ha
+- he
+- hi
+- hr
+- hu
+- hy
+- id
+- is
+- it
+- ja
+- ka
+- kk
+- km
+- kn
+- ko
+- ku
+- ky
+- la
+- lo
+- lt
+- lv
+- mk
+- ml
+- mn
+- mr
+- ms
+- my
+- ne
+- nl
+- no
+- or
+- pa
+- pl
+- ps
+- pt
+- ro
+- ru
+- sa
+- si
+- sk
+- sl
+- so
+- sq
+- sr
+- sv
+- sw
+- ta
+- te
+- th
+- tl
+- tr
+- uk
+- ur
+- uz
+- vi
+- zh
+license: apache-2.0
+datasets:
+- ms_marco
+- sentence-transformers/msmarco-hard-negatives
+metrics:
+- recall
 tags:
 - feature-extraction
 - sentence-similarity
+library_name: sentence-transformers
 ---
+<h1 align="center">DPR-XM</h1>
+<h4 align="center">
+  <p>
+      <a href=#usage>🛠️ Usage</a>  |
+      <a href="#evaluation">📊 Evaluation</a> |
+      <a href="#train">🤖 Training</a> |
+      <a href="#citation">🔗 Citation</a> |
+      <a href="#license">🔑 License</a>
+  <p>
+  <p>
+    <a href="https://github.com/ant-louis/xm-retrievers">💻 Code</a>  |
+    <a href="https://arxiv.org/abs/">📄 Paper</a>
+  <p>
+</h4>
+This is a [sentence-transformers](https://www.SBERT.net) model. It maps questions and paragraphs 768-dimensional dense vectors and can be used for semantic search. The model uses an [XMOD](https://huggingface.co/facebook/xmod-base) backbone, which allows it to learn from monolingual fine-tuning in a high-resource language, like English, and perform zero-shot retrieval across multiple languages.
+## Usage
+Here are some examples for using DPR-XM with [Sentence-Transformers](#using-sentence-transformers), [FlagEmbedding](#using-flagembedding), and [Huggingface Transformers](#using-huggingface-transformers).
+#### Using Sentence-Transformers
+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
+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."]
+language_code = "fr_FR" #Find all codes here: https://huggingface.co/facebook/xmod-base#languages
+model = SentenceTransformer('antoinelouis/dpr-xm')
+model[0].auto_model.set_default_language(language_code) #Activate the language-specific adapters
+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
+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
+from torch.nn.functional import normalize
 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)
+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."]
+language_code = "fr_FR" #Find all codes here: https://huggingface.co/facebook/xmod-base#languages
+tokenizer = AutoTokenizer.from_pretrained('antoinelouis/dpr-xm')
+model = AutoModel.from_pretrained('antoinelouis/dpr-xm')
+model.set_default_language(language_code) #Activate the language-specific adapters
+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():
+    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)
+```
+#### 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."]
+language_code = "fr_FR" #Find all codes here: https://huggingface.co/facebook/xmod-base#languages
+model = FlagModel('antoinelouis/dpr-xm')
+model.model.set_default_language(language_code) #Activate the language-specific adapters
+q_embeddings = model.encode(queries, normalize_embeddings=True)
+p_embeddings = model.encode(passages, normalize_embeddings=True)
+similarity = q_embeddings @ p_embeddings.T
+print(similarity)
+```
+***
+## Evaluation
+- **MS MARCO**:
+We evaluate our model on the small development set of [MS MARCO](https://ir-datasets.com/msmarco-passage.html#msmarco-passage/dev/small), which consists of 6,980 queries for a corpus of 8.8M candidate passages. Below, we compared its performance with other retrieval models on the official metrics for the dataset, i.e., mean reciprocal rank at cut-off 10 (MRR@10).
+|    | model                                                                                                                           |          Type | #Samples | #Params |   en |   es |   fr |   it |   pt |   id |   de |   ru |   zh |   ja |   nl |   vi |   hi |   ar | Avg. |
+|---:|:--------------------------------------------------------------------------------------------------------------------------------|:--------------|:---------|--------:|-----:|-----:|-----:|-----:|-----:|-----:|-----:|-----:|-----:|-----:|-----:|-----:|-----:|-----:|-----:|
+|  1 | BM25 ([Pyserini](https://github.com/castorini/pyserini))                                                                        |       lexical |        - |       - | 18.4 | 15.8 | 15.5 | 15.3 | 15.2 | 14.9 | 13.6 | 12.4 | 11.6 | 14.1 | 14.0 | 13.6 | 13.4 | 11.1 | 14.2 |
+|  2 | mono-mT5 ([Bonfacio et al., 2021](https://arxiv.org/abs/2108.13897))                                                            | cross-encoder |    12.8M |    390M | 36.6 | 31.4 | 30.2 | 30.3 | 30.2 | 29.8 | 28.9 | 26.3 | 24.9 | 26.7 | 29.2 | 25.6 | 26.6 | 23.5 | 28.6 |
+|  3 | mono-mMiniLM ([Bonfacio et al., 2021](https://arxiv.org/abs/2108.13897))                                                        | cross-encoder |    80.0M |    107M | 36.6 | 30.9 | 29.6 | 29.1 | 28.9 | 29.3 | 27.8 | 25.1 | 24.9 | 26.3 | 27.6 | 24.7 | 26.2 | 21.9 | 27.8 |
+|  4 | [DPR-X](https://huggingface.co/eugene-yang/dpr-xlmr-large-mtt-neuclir) ([Yang et al., 2022](https://arxiv.org/abs/2204.11989))  | single-vector |    25.6M |    550M | 24.5 | 19.6 | 18.9 | 18.3 | 19.0 | 16.9 | 18.2 | 17.7 | 14.8 | 15.4 | 18.5 | 15.1 | 15.4 | 12.9 | 17.5 |
+|  5 | [mE5-base](https://huggingface.co/intfloat/multilingual-e5-base) ([Wang et al., 2024](https://arxiv.org/abs/2402.05672))        | single-vector |     5.1B |    278M | 35.0 | 28.9 | 30.3 | 28.0 | 27.5 | 26.1 | 27.1 | 24.5 | 22.9 | 25.0 | 27.3 | 23.9 | 24.2 | 20.5 | 26.5 |
+|  6 | mColBERT ([Bonfacio et al., 2021](https://arxiv.org/abs/2108.13897))                                                            |  multi-vector |    25.6M |    180M | 35.2 | 30.1 | 28.9 | 29.2 | 29.2 | 27.5 | 28.1 | 25.0 | 24.6 | 23.6 | 27.3 | 18.0 | 23.2 | 20.9 | 26.5 |
+|    |                                                                                                                                 |               |          |         |      |      |      |      |      |      |      |      |      |      |      |      |      |      |      |
+|  7 | **DPR-XM** (ours)                                                                                                               | single-vector |    25.6M |    277M | 32.7 | 23.6 | 23.5 | 22.3 | 22.7 | 22.0 | 22.1 | 19.9 | 18.1 | 18.7 | 22.9 | 18.0 | 16.0 | 15.1 | 21.3 |
+|  8 | [ColBERT-XM](https://huggingface.co/antoinelouis/colbert-xm) (ours)                                                             |  multi-vector |     6.4M |    277M | 37.2 | 28.5 | 26.9 | 26.5 | 27.6 | 26.3 | 27.0 | 25.1 | 24.6 | 24.1 | 27.5 | 22.6 | 23.8 | 19.5 | 26.2 |
+***
 ## Training
+#### Background
+We use the [xmod-base](https://huggingface.co/facebook/xmod-base) backbone and fine-tune it on 25.6M MS MARCO triples. We optimize the model with 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 the dataset. Formally, we compute the cos similarity from each possible sentence pairs from the batch. We then apply the cross entropy loss with a temperature of 0.05 by comparing with true pairs.
+#### Hyperparameters
+We traine the model on a single Tesla V100 GPU with 32GBs of memory for 200k steps using a batch size of 128. We use the AdamW optimizer with a peak learning rate of 2e-5 with warm up along the first 10\% of training steps and linear scheduling. The sequence length was limited to 128 tokens.
+#### Data
+We use training triples from the [MS MARCO passage ranking](https://ir-datasets.com/msmarco-passage.html#msmarco-passage/train) dataset, which contains 8.8M passages and 539K training queries. We sample hard negatives mined from 12 distinct dense retrievers using the [msmarco-hard-negatives](https://huggingface.co/datasets/sentence-transformers/msmarco-hard-negatives) distillation dataset.
+***
+## Citation
+```bibtex
+@article{louis2024modular,
+  author = {Louis, Antoine and Saxena, Vageesh and van Dijck, Gijs and Spanakis, Gerasimos},
+  title = {ColBERT-XM: A Modular Multi-Vector Representation Model for Zero-Shot Multilingual Information Retrieval},
+  journal = {CoRR},
+  volume = {abs/2402.xxxxx},
+  year = {2024},
+  url = {https://doi.org/},
+  doi = {},
+  eprinttype = {arXiv},
+  eprint = {2402.xxxxx},
+}
 ```
+## License
+DPR-XM is licensed under the [Apache 2.0](https://opensource.org/license/apache-2-0/) license.