Initial upload

README.md

@@ -1,3 +1,303 @@
----
-license: apache-2.0
----
+---
+language:
+- fr
+- nl
+- de
+- en
+license: apache-2.0
+tags:
+- sentence-transformers
+- sentence-similarity
+- feature-extraction
+- generated_from_trainer
+- dataset_size:8066634
+- loss:MultipleNegativesRankingLoss
+widget:
+- source_sentence: These three mysterious men came to our help.
+  sentences:
+  - Three strange guys helped us then.
+  - These three black birds came in our garden.
+  - Some people are helpful.
+  - One, two, three... Who can guess the next digits?
+pipeline_tag: sentence-similarity
+library_name: sentence-transformers
+---
+
+# FMMB-BE: The Fairly Multilingual ModernBERT Embedding Model (Belgian Edition)
+
+🇧🇪 The Fairly Multilingual ModernBERT Embedding Model (Belgian Edition) is the perfect model for embedding texts up to 8192 tokens written in French, Dutch, German or English at the speed of light. This model uses the most effecient tokenizer for each input text, thereby maximizing your GPU usage. Despite using 4 different tokenizers and 4 different embedding tables, this model can mix and match different languages in the same batch, and produces embeddings very similar across languages. That said: if you know the tokenizer you want to use in advance, you can use the monolingual variants for [French](https://huggingface.co/Parallia/Fairly-Multilingual-ModernBERT-Embed-BE-FR), [Dutch](https://huggingface.co/Parallia/Fairly-Multilingual-ModernBERT-Embed-BE-NL), [German](https://huggingface.co/Parallia/Fairly-Multilingual-ModernBERT-Embed-BE-DE) or [English](https://huggingface.co/Parallia/Fairly-Multilingual-ModernBERT-Embed-BE-EN) for a faster tokenization and lower memory footprint.
+
+🆘 This [sentence-transformers](https://www.SBERT.net) model was trained on a small parallel corpus containing English-French, English-Dutch, and English-German sentence pairs. It maps sentences & paragraphs to a 768-dimensional dense vector space and can be used for semantic textual similarity, semantic search, paraphrase mining, text classification, clustering, and more. The input texts can be used as-is, no need to use prefixes.
+
+🪄 Thanks to the magic of [Trans-Tokenization](https://huggingface.co/papers/2408.04303), monoligual English models such as [ModernBERT-Embed from Nomic AI](https://huggingface.co/nomic-ai/modernbert-embed-base) can be turned into embedding models for another language. And this, with almost no GPU compute involved! 🤯
+
+⚖️ Each of the 5 FMMB-BE models are actually copies of the exact same model, paired with different tokenizers and embedding tables. Indeed, as all trans-tokenized models operate on embeddings in the same latent space, aligning them cross-lingually is a breeze: after creating a "super" model which can speak in all of the 4 tokenizers, this model can be finetuned to produce similar embeddings for sentences which are translation of each other.
+
+⚡ ModernBERT, developped last month by Answer Ai and LightOn, is about 3x to 6x faster at inference time than regular BERT/RoBERTa models, while providing us with superior results. This makes it a wonderful choice for many use cases.
+
+
+## Model Details
+
+### Model Description
+- **Model Type:** Sentence Transformer
+- **Base model:** [ModernBERT-Embed-Base](https://huggingface.co/nomic-ai/modernbert-embed-base)
+- **Maximum Sequence Length:** 8192 tokens
+- **Output Dimensionality:** 768 dimensions
+- **Similarity Function:** Cosine Similarity
+- **Training Dataset:**
+    - parallel-sentences
+- **Languages:** nl
+- **License:** apache-2.0
+
+### Full Model Architecture
+
+```
+SentenceTransformer(
+  (0): Transformer({'max_seq_length': 8192, 'do_lower_case': False}) with Transformer model: ModernBertModel 
+  (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, 'include_prompt': True})
+)
+```
+
+## Usage
+
+**IMPORTANT:** While waiting for the next stable release of the `transformers` library, please install the latest git release to use `modernbert` models:
+
+```bash
+pip install --upgrade git+https://github.com/huggingface/transformers.git
+```
+
+The easiest way to use this model is to install the Sentence Transformers library:
+
+```bash
+pip install -U sentence-transformers
+```
+
+Then you can load this model and run inference.
+```python
+from sentence_transformers import SentenceTransformer
+
+# Download from the 🤗 Hub
+model = SentenceTransformer("Parallia/Fairly-Multilingual-ModernBERT-Embed-BE")
+# Run inference
+sentences = [
+    'These three mysterious men came to our help.',
+    'Three strange guys helped us then.',
+    'These three black birds came in our garden.',
+    'Some people are helpful.',
+    'One, two, three... Who can guess the next digits?',
+]
+embeddings = model.encode(sentences)
+print(embeddings.shape)
+# [5, 768]
+
+# Get the similarity scores for the embeddings
+similarities = model.similarity(embeddings, embeddings)
+print(similarities.shape)
+# [5, 5]
+```
+
+<!--
+### Recommendations
+
+*What are recommendations with respect to the foreseeable issues? For example, filtering explicit content.*
+-->
+
+## Training Details
+
+### Training Dataset
+
+#### parallel-sentences
+
+* Dataset: parallel dataset
+* Size: 8,066,634 training samples
+* Columns: <code>sent1</code> and <code>sent2</code>
+* Approximate statistics based on the first 1000 samples:
+  |         | sent1                                                                             | sent2                                                                             |
+  |:--------|:----------------------------------------------------------------------------------|:----------------------------------------------------------------------------------|
+  | type    | string                                                                            | string                                                                            |
+  | details | <ul><li>min: 6 tokens</li><li>mean: 17.86 tokens</li><li>max: 46 tokens</li></ul> | <ul><li>min: 6 tokens</li><li>mean: 18.87 tokens</li><li>max: 52 tokens</li></ul> |
+* Samples:
+  | sent1                                                                                                                                                     | sent2                                                                                                                                                                               |
+  |:----------------------------------------------------------------------------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+  | <code>The faces may change, but the essential views that have characterised Israel’s government for decades will remain the same after 9 April</code> | <code>Les visages peuvent changer, mais les opinions fondamentales qui caractérisent le gouvernement israélien depuis des décennies resteront les mêmes après le 9 avril</code> |
+  | <code>- Yeah. My husband never talked about business.</code>                                                                                          | <code>M'n man had het nooit over z'n zaken.</code>                                                                                                                              |
+  | <code>Or do they think that We hear not their secrets and their private counsels?</code>                                                              | <code>Oder meinen sie, daß Wir ihre Geheimnisse und heimlichen Beratungen nicht hören?</code> |
+* Loss: [<code>MultipleNegativesRankingLoss</code>](https://sbert.net/docs/package_reference/sentence_transformer/losses.html#multiplenegativesrankingloss) with these parameters:
+  ```json
+  {
+      "scale": 20.0,
+      "similarity_fct": "cos_sim"
+  }
+  ```
+
+### Training Hyperparameters
+#### Non-Default Hyperparameters
+
+- `eval_strategy`: steps
+- `per_device_train_batch_size`: 256
+- `per_device_eval_batch_size`: 256
+- `learning_rate`: 2e-05
+- `num_train_epochs`: 1
+- `warmup_ratio`: 0.1
+- `bf16`: True
+
+#### All Hyperparameters
+<details><summary>Click to expand</summary>
+
+- `overwrite_output_dir`: False
+- `do_predict`: False
+- `eval_strategy`: steps
+- `prediction_loss_only`: True
+- `per_device_train_batch_size`: 256
+- `per_device_eval_batch_size`: 256
+- `per_gpu_train_batch_size`: None
+- `per_gpu_eval_batch_size`: None
+- `gradient_accumulation_steps`: 1
+- `eval_accumulation_steps`: None
+- `torch_empty_cache_steps`: None
+- `learning_rate`: 2e-05
+- `weight_decay`: 0.0
+- `adam_beta1`: 0.9
+- `adam_beta2`: 0.999
+- `adam_epsilon`: 1e-08
+- `max_grad_norm`: 1.0
+- `num_train_epochs`: 1
+- `max_steps`: -1
+- `lr_scheduler_type`: linear
+- `lr_scheduler_kwargs`: {}
+- `warmup_ratio`: 0.1
+- `warmup_steps`: 0
+- `log_level`: passive
+- `log_level_replica`: warning
+- `log_on_each_node`: True
+- `logging_nan_inf_filter`: True
+- `save_safetensors`: True
+- `save_on_each_node`: False
+- `save_only_model`: False
+- `restore_callback_states_from_checkpoint`: False
+- `no_cuda`: False
+- `use_cpu`: False
+- `use_mps_device`: False
+- `seed`: 42
+- `data_seed`: None
+- `jit_mode_eval`: False
+- `use_ipex`: False
+- `bf16`: True
+- `fp16`: False
+- `fp16_opt_level`: O1
+- `half_precision_backend`: auto
+- `bf16_full_eval`: False
+- `fp16_full_eval`: False
+- `tf32`: None
+- `local_rank`: 0
+- `ddp_backend`: None
+- `tpu_num_cores`: None
+- `tpu_metrics_debug`: False
+- `debug`: []
+- `dataloader_drop_last`: False
+- `dataloader_num_workers`: 0
+- `dataloader_prefetch_factor`: None
+- `past_index`: -1
+- `disable_tqdm`: False
+- `remove_unused_columns`: True
+- `label_names`: None
+- `load_best_model_at_end`: False
+- `ignore_data_skip`: False
+- `fsdp`: []
+- `fsdp_min_num_params`: 0
+- `fsdp_config`: {'min_num_params': 0, 'xla': False, 'xla_fsdp_v2': False, 'xla_fsdp_grad_ckpt': False}
+- `fsdp_transformer_layer_cls_to_wrap`: None
+- `accelerator_config`: {'split_batches': False, 'dispatch_batches': None, 'even_batches': True, 'use_seedable_sampler': True, 'non_blocking': False, 'gradient_accumulation_kwargs': None}
+- `deepspeed`: None
+- `label_smoothing_factor`: 0.0
+- `optim`: adamw_torch
+- `optim_args`: None
+- `adafactor`: False
+- `group_by_length`: False
+- `length_column_name`: length
+- `ddp_find_unused_parameters`: None
+- `ddp_bucket_cap_mb`: None
+- `ddp_broadcast_buffers`: False
+- `dataloader_pin_memory`: True
+- `dataloader_persistent_workers`: False
+- `skip_memory_metrics`: True
+- `use_legacy_prediction_loop`: False
+- `push_to_hub`: False
+- `resume_from_checkpoint`: None
+- `hub_model_id`: None
+- `hub_strategy`: every_save
+- `hub_private_repo`: None
+- `hub_always_push`: False
+- `gradient_checkpointing`: False
+- `gradient_checkpointing_kwargs`: None
+- `include_inputs_for_metrics`: False
+- `include_for_metrics`: []
+- `eval_do_concat_batches`: True
+- `fp16_backend`: auto
+- `push_to_hub_model_id`: None
+- `push_to_hub_organization`: None
+- `mp_parameters`: 
+- `auto_find_batch_size`: False
+- `full_determinism`: False
+- `torchdynamo`: None
+- `ray_scope`: last
+- `ddp_timeout`: 1800
+- `torch_compile`: False
+- `torch_compile_backend`: None
+- `torch_compile_mode`: None
+- `dispatch_batches`: None
+- `split_batches`: None
+- `include_tokens_per_second`: False
+- `include_num_input_tokens_seen`: False
+- `neftune_noise_alpha`: None
+- `optim_target_modules`: None
+- `batch_eval_metrics`: False
+- `eval_on_start`: False
+- `use_liger_kernel`: False
+- `eval_use_gather_object`: False
+- `average_tokens_across_devices`: False
+- `prompts`: None
+- `batch_sampler`: batch_sampler
+- `multi_dataset_batch_sampler`: proportional
+
+</details>
+
+### Framework Versions
+- Python: 3.11.7
+- Sentence Transformers: 3.3.1
+- Transformers: 4.48.0.dev0
+- PyTorch: 2.2.0+cu121
+- Accelerate: 1.0.1
+- Datasets: 3.2.0
+- Tokenizers: 0.21.0
+
+## Citation
+
+If you use or finetune this model, please consider citing this paper and the sentence-transformers library:
+
+### BibTeX
+
+### This model
+```bibtex
+@misc{henderson2017efficient,
+    title={The Fairly Multilingual ModernBERT Embbeding Model -- Belgian Edition},
+    author={Francois Remy},
+    year={2025},
+    eprint={2501.99999},
+    archivePrefix={arXiv},
+    primaryClass={cs.CL}
+}
+```
+
+#### Sentence Transformers
+```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 = "https://arxiv.org/abs/1908.10084",
+}
+```

config.json

@@ -0,0 +1,50 @@
+{
+  "_name_or_path": "Parallia/Fairly-Multilingual-ModernBERT-Embed-BE-NL",
+  "additional_special_tokens_ids": [],
+  "architectures": [
+    "ModernBertModel"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "bos_token_id": 1,
+  "classifier_activation": "gelu",
+  "classifier_bias": false,
+  "classifier_dropout": 0.0,
+  "classifier_pooling": "mean",
+  "cls_token_id": null,
+  "decoder_bias": true,
+  "deterministic_flash_attn": false,
+  "embedding_dropout": 0.0,
+  "eos_token_id": 2,
+  "global_attn_every_n_layers": 3,
+  "global_rope_theta": 160000.0,
+  "gradient_checkpointing": false,
+  "hidden_activation": "gelu",
+  "hidden_size": 768,
+  "initializer_cutoff_factor": 2.0,
+  "initializer_range": 0.02,
+  "intermediate_size": 1152,
+  "layer_norm_eps": 1e-05,
+  "local_attention": 128,
+  "local_rope_theta": 10000.0,
+  "mask_token_id": null,
+  "max_position_embeddings": 8192,
+  "mlp_bias": false,
+  "mlp_dropout": 0.0,
+  "model_type": "modernbert",
+  "norm_bias": false,
+  "norm_eps": 1e-05,
+  "num_attention_heads": 12,
+  "num_hidden_layers": 22,
+  "pad_token_id": null,
+  "position_embedding_type": "absolute",
+  "reference_compile": false,
+  "sep_token_id": null,
+  "sparse_pred_ignore_index": -100,
+  "sparse_prediction": false,
+  "tokenizer_class": "LlamaTokenizerFast",
+  "torch_dtype": "float32",
+  "transformers_version": "4.48.0.dev0",
+  "unk_token_id": 0,
+  "vocab_size": 200368
+}

config_sentence_transformers.json

@@ -0,0 +1,10 @@
+{
+  "__version__": {
+    "sentence_transformers": "3.3.1",
+    "transformers": "4.48.0.dev0",
+    "pytorch": "2.2.0+cu121"
+  },
+  "prompts": {},
+  "default_prompt_name": null,
+  "similarity_fn_name": "cosine"
+}

model.safetensors

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

modules.json

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

pick_best_tokenizer.py

@@ -0,0 +1,105 @@
+import os
+import json
+import random
+from typing import List, Dict
+from transformers import PreTrainedTokenizer, AutoTokenizer
+
+#pbt_log = []
+class PickBestTokenizer(PreTrainedTokenizer):
+    def __init__(self, tokenizers: List[PreTrainedTokenizer], **kwargs):
+        self.model_input_names = ["input_ids", "attention_mask"]
+        self.tokenizers = [AutoTokenizer.from_pretrained(tokenizer) if isinstance(tokenizer,str) else tokenizer for tokenizer in tokenizers]
+        self.tokenizers_offsets = []
+        self.vocab = {}
+        self._vocab_size = sum(len(tokenizer) for tokenizer in self.tokenizers)
+        
+        offset = 0
+        for i, tokenizer in enumerate(self.tokenizers):
+            tokenizer_id = f"[{i}]"
+            self.tokenizers_offsets.append(offset)
+            for token, token_id in tokenizer.get_vocab().items():
+                self.vocab[tokenizer_id + token] = token_id + offset
+            offset += len(tokenizer)
+        
+        super().__init__(**kwargs)
+
+    @property
+    def vocab_size(self) -> int:
+        return self._vocab_size
+
+    def get_vocab(self) -> Dict[str, int]:
+        return self.vocab
+
+    def tokenize(self, text: str, **kwargs) -> List[str]:
+        # Tokenize the text with all possible tokenizers
+        tokenized_texts = [
+            [f"[{i}]" + tok for tok in tokenizer.tokenize(text, **kwargs)]
+            for i, tokenizer in enumerate(self.tokenizers)
+        ]
+
+        # Ensure that in case of equal lengths, no tokenizer is favored
+        random.shuffle(tokenized_texts)
+        
+        # Return the list of tokens which is shortest
+        best_tokenization = min(tokenized_texts, key=len)
+
+        # Log the output
+        #pbt_log.append((text, best_tokenization))
+
+        # Return the output
+        return best_tokenization
+
+    def convert_tokens_to_ids(self, tokens: List[str], **kwargs) -> List[int]:
+        if isinstance(tokens, str): return self.convert_tokens_to_ids([tokens])[0]
+        ids = []
+        for token in tokens:
+            tokenizer_id = int(token[1])
+            token_stripped = token[3:]
+            offset = self.tokenizers_offsets[tokenizer_id]
+            ids.append(self.tokenizers[tokenizer_id].convert_tokens_to_ids(token_stripped, **kwargs) + offset)
+        return ids
+
+    def convert_ids_to_tokens(self, ids: List[int], **kwargs) -> List[str]:
+        if isinstance(ids, int): return self.convert_ids_to_tokens([ids])[0]
+        tokens = []
+        for id in ids:
+            for i, offset in enumerate(self.tokenizers_offsets):
+                if id < offset + len(self.tokenizers[i]):
+                    token_id = id - offset
+                    tokens.append(f"[{i}]{self.tokenizers[i].convert_ids_to_tokens(token_id, **kwargs)}")
+                    break
+            else:
+                raise ValueError(f"ID {id} is out of range for any tokenizer.")
+        return tokens
+
+    def _convert_token_to_id(self, token: str) -> int:
+        raise NotImplementedError("This method should not be used in this class.")
+
+    def _convert_id_to_token(self, index: int) -> str:
+        raise NotImplementedError("This method should not be used in this class.")
+
+    def save_pretrained(self, path, *args, **kwargs):
+        # ensure the save path exists
+        os.makedirs(path, exist_ok=True)
+        # save this file in the repository as `pick_best_tokenizer.py`
+        from pathlib import Path
+        source = Path(__file__)
+        destination = Path(path+'/pick_best_tokenizer.py')
+        destination.write_bytes(source.read_bytes())
+        # save the config
+        config = {
+            "tokenizer_class": "PickBestTokenizer",
+            "auto_map": ["pick_best_tokenizer.PickBestTokenizer", None],
+            "tokenizers": [tokenizer.name_or_path for tokenizer in self.tokenizers]
+        }
+        with open(path+'/tokenizer_config.json', 'w') as f:
+            json.dump(config, f)
+
+# Example usage
+#tokenizer_fr = AutoTokenizer.from_pretrained("tokenizers/fineweb2_fr")
+#tokenizer_nl = AutoTokenizer.from_pretrained("tokenizers/fineweb2_nl")
+#tokenizer_de = AutoTokenizer.from_pretrained("tokenizers/fineweb2_de")
+#tokenizer_en = AutoTokenizer.from_pretrained("answerdotai/ModernBERT-base")
+#pick_best_tokenizer = PickBestTokenizer([tokenizer_fr, tokenizer_nl, tokenizer_de, tokenizer_en])
+
+PickBestTokenizer.register_for_auto_class("AutoTokenizer")

sentence_bert_config.json

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

tokenizer_config.json

@@ -0,0 +1,5 @@
+{
+    "tokenizer_class": "PickBestTokenizer",
+    "auto_map": ["pick_best_tokenizer.PickBestTokenizer", null],
+    "tokenizers": ["Parallia/Fairly-Multilingual-ModernBERT-Embed-BE-FR","Parallia/Fairly-Multilingual-ModernBERT-Embed-BE-NL","Parallia/Fairly-Multilingual-ModernBERT-Embed-BE-DE","Parallia/Fairly-Multilingual-ModernBERT-Embed-BE-EN"]
+}