mteb 2.7.12__py3-none-any.whl → 2.7.13__py3-none-any.whl

mteb/models/model_implementations/nomic_models.py

@@ -7,6 +7,7 @@ import torch
 import torch.nn.functional as F
 from packaging.version import Version
 
+from mteb.models import sentence_transformers_loader
 from mteb.models.model_meta import ModelMeta, ScoringFunction
 from mteb.models.sentence_transformer_wrapper import SentenceTransformerEncoderWrapper
 from mteb.types import PromptType
@@ -509,3 +510,42 @@ nomic_embed_text_v2_moe = ModelMeta(
       url={https://arxiv.org/abs/2502.07972},
 }""",
 )
+
+nomic_embed_code = ModelMeta(
+    loader=sentence_transformers_loader,
+    loader_kwargs={
+        "trust_remote_code": True,
+        "model_prompts": model_prompts,
+    },
+    name="nomic-ai/nomic-embed-code",
+    revision="11114029805cee545ef111d5144b623787462a52",
+    release_date="2025-03-24",
+    languages=["eng-Latn"],
+    n_parameters=7_070_619_136,
+    n_embedding_parameters=None,
+    memory_usage_mb=26972.0,
+    max_tokens=32768,
+    embed_dim=3584,
+    license="apache-2.0",
+    open_weights=True,
+    public_training_code="https://github.com/gangiswag/cornstack/",
+    public_training_data="https://huggingface.co/collections/nomic-ai/cornstack",
+    framework=["PyTorch", "Sentence Transformers", "safetensors"],
+    reference="https://huggingface.co/nomic-ai/nomic-embed-code",
+    similarity_fn_name=ScoringFunction.COSINE,
+    use_instructions=True,
+    training_datasets={"CoRNStack"},
+    adapted_from=None,
+    superseded_by=None,
+    modalities=["text"],
+    model_type=["dense"],
+    citation="""@misc{suresh2025cornstackhighqualitycontrastivedata,
+      title={CoRNStack: High-Quality Contrastive Data for Better Code Retrieval and Reranking},
+      author={Tarun Suresh and Revanth Gangi Reddy and Yifei Xu and Zach Nussbaum and Andriy Mulyar and Brandon Duderstadt and Heng Ji},
+      year={2025},
+      eprint={2412.01007},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2412.01007},
+}""",
+)

mteb/models/model_implementations/nvidia_llama_nemoretriever_colemb.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any
 
 import torch
-from packaging.version import Version
+from packaging.specifiers import SpecifierSet
 from torch.utils.data import DataLoader
 from transformers import __version__ as transformers_version
 
@@ -31,18 +31,20 @@ class LlamaNemoretrieverColembed(AbsEncoder):
         model_name_or_path: str,
         revision: str,
         trust_remote_code: bool,
+        transformers_version_constraint: str | None = None,
         device_map="cuda",
         torch_dtype=torch.bfloat16,
         attn_implementation="flash_attention_2",
         **kwargs,
     ):
-        required_transformers_version = "4.49.0"
-
-        if Version(transformers_version) != Version(required_transformers_version):
-            raise RuntimeError(
-                f"transformers version {transformers_version} is not match with required "
-                f"install version {required_transformers_version} to run `nvidia/llama-nemoretriever-colembed`"
-            )
+        if transformers_version_constraint is not None:
+            spec = SpecifierSet(transformers_version_constraint)
+            if transformers_version not in spec:
+                raise RuntimeError(
+                    f"Model `{model_name_or_path}` requires transformers{transformers_version_constraint}, "
+                    f"but {transformers_version} is installed. "
+                    f"Run: pip install 'transformers{transformers_version_constraint}'"
+                )
 
         from transformers import AutoModel
 
@@ -150,10 +152,24 @@ TRAINING_DATA = {
     "wiki-ss-nq",
 }
 
+
+TRAINING_DATA_v2 = {
+    "VidoreDocVQARetrieval",
+    "VidoreInfoVQARetrieval",
+    "VidoreTatdqaRetrieval",
+    "VidoreArxivQARetrieval",
+    "docmatix-ir",
+    "VDRMultilingualRetrieval",
+    "VisRAG-Ret-Train-Synthetic-data",
+    "VisRAG-Ret-Train-In-domain-data",
+    "wiki-ss-nq",
+}
+
 llama_nemoretriever_colembed_1b_v1 = ModelMeta(
     loader=LlamaNemoretrieverColembed,
     loader_kwargs=dict(
         trust_remote_code=True,
+        transformers_version_constraint="==4.49.0",
     ),
     name="nvidia/llama-nemoretriever-colembed-1b-v1",
     model_type=["late-interaction"],
@@ -168,7 +184,7 @@ llama_nemoretriever_colembed_1b_v1 = ModelMeta(
     embed_dim=2048,
     license="https://huggingface.co/nvidia/llama-nemoretriever-colembed-1b-v1/blob/main/LICENSE",
     open_weights=True,
-    public_training_code="Proprietary Code",
+    public_training_code=None,
     public_training_data="https://huggingface.co/nvidia/llama-nemoretriever-colembed-1b-v1#training-dataset",
     framework=["PyTorch", "Transformers", "safetensors"],
     reference="https://huggingface.co/nvidia/llama-nemoretriever-colembed-1b-v1",
@@ -182,6 +198,7 @@ llama_nemoretriever_colembed_3b_v1 = ModelMeta(
     loader=LlamaNemoretrieverColembed,
     loader_kwargs=dict(
         trust_remote_code=True,
+        transformers_version_constraint="==4.49.0",
     ),
     name="nvidia/llama-nemoretriever-colembed-3b-v1",
     model_type=["late-interaction"],
@@ -196,7 +213,7 @@ llama_nemoretriever_colembed_3b_v1 = ModelMeta(
     embed_dim=3072,
     license="https://huggingface.co/nvidia/llama-nemoretriever-colembed-1b-v1/blob/main/LICENSE",
     open_weights=True,
-    public_training_code="Proprietary Code",
+    public_training_code=None,
     public_training_data="https://huggingface.co/nvidia/llama-nemoretriever-colembed-1b-v1#training-dataset",
     framework=["PyTorch", "Transformers", "safetensors"],
     reference="https://huggingface.co/nvidia/llama-nemoretriever-colembed-3b-v1",
@@ -205,3 +222,86 @@ llama_nemoretriever_colembed_3b_v1 = ModelMeta(
     training_datasets=TRAINING_DATA,
     citation=LLAMA_NEMORETRIEVER_CITATION,
 )
+
+llama_nemotron_colembed_vl_3b_v2 = ModelMeta(
+    loader=LlamaNemoretrieverColembed,
+    loader_kwargs=dict(
+        trust_remote_code=True,
+        transformers_version_constraint="==4.49.0",
+    ),
+    name="nvidia/llama-nemotron-colembed-vl-3b-v2",
+    model_type=["late-interaction"],
+    languages=["eng-Latn"],
+    revision="75f03c712cb3a252e062295f9a0966e5d95d6156",
+    release_date="2026-01-21",
+    modalities=["image", "text"],
+    n_parameters=4_407_000_000,
+    memory_usage_mb=8403,
+    max_tokens=8192,
+    embed_dim=3072,
+    license="https://huggingface.co/nvidia/llama-nemotron-colembed-vl-3b-v2/blob/main/LICENSE",
+    open_weights=True,
+    public_training_code=None,
+    public_training_data="https://huggingface.co/nvidia/llama-nemotron-colembed-vl-3b-v2#training-dataset",
+    framework=["PyTorch", "Transformers", "safetensors"],
+    reference="https://huggingface.co/nvidia/llama-nemotron-colembed-vl-3b-v2",
+    similarity_fn_name="MaxSim",
+    use_instructions=True,
+    training_datasets=TRAINING_DATA,
+    citation=LLAMA_NEMORETRIEVER_CITATION,
+)
+
+nemotron_colembed_vl_4b_v2 = ModelMeta(
+    loader=LlamaNemoretrieverColembed,
+    loader_kwargs=dict(
+        trust_remote_code=True,
+        transformers_version_constraint="==5.0.0rc0",
+    ),
+    name="nvidia/nemotron-colembed-vl-4b-v2",
+    revision="823b1625c15fe3da73fa094205e538a7a2301a2a",
+    languages=["eng-Latn"],
+    release_date="2026-01-07",
+    modalities=["image", "text"],
+    n_parameters=4_800_000_000,
+    memory_usage_mb=9206,
+    max_tokens=262144,
+    embed_dim=2560,
+    license="https://huggingface.co/nvidia/nemotron-colembed-vl-4b-v2/blob/main/LICENSE",
+    open_weights=True,
+    public_training_code=None,
+    public_training_data="https://huggingface.co/nvidia/nemotron-colembed-vl-4b-v2#training-dataset",
+    framework=["PyTorch", "Transformers"],
+    reference="https://huggingface.co/nvidia/nemotron-colembed-vl-4b-v2",
+    similarity_fn_name="MaxSim",
+    use_instructions=True,
+    training_datasets=TRAINING_DATA_v2,
+    citation=LLAMA_NEMORETRIEVER_CITATION,
+)
+
+
+nemotron_colembed_vl_8b_v2 = ModelMeta(
+    loader=LlamaNemoretrieverColembed,
+    loader_kwargs=dict(
+        trust_remote_code=True,
+        transformers_version_constraint="==5.0.0rc0",
+    ),
+    name="nvidia/nemotron-colembed-vl-8b-v2",
+    revision="6cbe43579dda6237768fc373768ad372cc5cdfec",
+    languages=["eng-Latn"],
+    release_date="2026-01-07",
+    modalities=["image", "text"],
+    n_parameters=8_700_000_000,
+    memory_usage_mb=16722,
+    max_tokens=262144,
+    embed_dim=4096,
+    license="https://huggingface.co/nvidia/nemotron-colembed-vl-8b-v2/blob/main/LICENSE",
+    open_weights=True,
+    public_training_code=None,
+    public_training_data="https://huggingface.co/nvidia/nemotron-colembed-vl-8b-v2#training-dataset",
+    framework=["PyTorch", "Transformers"],
+    reference="https://huggingface.co/nvidia/nemotron-colembed-vl-8b-v2",
+    similarity_fn_name="MaxSim",
+    use_instructions=True,
+    training_datasets=TRAINING_DATA_v2,
+    citation=LLAMA_NEMORETRIEVER_CITATION,
+)

mteb/models/model_implementations/ops_colqwen3_models.py

@@ -0,0 +1,267 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import torch
+from tqdm.auto import tqdm
+from transformers import AutoModel, AutoProcessor
+
+from mteb._requires_package import requires_image_dependencies
+from mteb.models.abs_encoder import AbsEncoder
+from mteb.models.model_meta import ModelMeta, ScoringFunction
+
+if TYPE_CHECKING:
+    from torch.utils.data import DataLoader
+
+    from mteb.abstasks.task_metadata import TaskMetadata
+    from mteb.types import Array, BatchedInput, PromptType
+
+
+class OpsColQwen3Wrapper(AbsEncoder):
+    """Wrapper for OpsColQwen3 model."""
+
+    def __init__(
+        self,
+        model_name: str = "OpenSearch-AI/Ops-Colqwen3-4B",
+        revision: str | None = None,
+        device: str | None = None,
+        attn_implementation: str | None = None,
+        **kwargs,
+    ):
+        requires_image_dependencies()
+        from transformers.utils.import_utils import is_flash_attn_2_available
+
+        if attn_implementation is None:
+            attn_implementation = (
+                "flash_attention_2" if is_flash_attn_2_available() else None
+            )
+
+        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+
+        self.mdl = AutoModel.from_pretrained(
+            model_name,
+            device_map=self.device,
+            attn_implementation=attn_implementation,
+            trust_remote_code=True,
+            revision=revision,
+            **kwargs,
+        )
+        self.mdl.eval()
+
+        self.processor = AutoProcessor.from_pretrained(
+            model_name,
+            trust_remote_code=True,
+        )
+
+    def encode(
+        self,
+        inputs: DataLoader[BatchedInput],
+        *,
+        task_metadata: TaskMetadata,
+        hf_split: str,
+        hf_subset: str,
+        prompt_type: PromptType | None = None,
+        **kwargs: Any,
+    ) -> Array:
+        text_embeddings = None
+        image_embeddings = None
+
+        if "text" in inputs.dataset.features:
+            text_embeddings = self.get_text_embeddings(inputs, **kwargs)
+        if "image" in inputs.dataset.features:
+            image_embeddings = self.get_image_embeddings(inputs, **kwargs)
+
+        if text_embeddings is not None and image_embeddings is not None:
+            if len(text_embeddings) != len(image_embeddings):
+                raise ValueError(
+                    "The number of texts and images must have the same length"
+                )
+            fused_embeddings = text_embeddings + image_embeddings
+            return fused_embeddings
+        elif text_embeddings is not None:
+            return text_embeddings
+        elif image_embeddings is not None:
+            return image_embeddings
+        raise ValueError("No text or image inputs found")
+
+    def encode_input(self, inputs):
+        return self.mdl(**inputs)
+
+    def get_image_embeddings(
+        self,
+        images: DataLoader,
+        batch_size: int = 32,
+        **kwargs,
+    ) -> torch.Tensor:
+        import torchvision.transforms.functional as F
+        from PIL import Image
+
+        all_embeds = []
+
+        with torch.no_grad():
+            for batch in tqdm(images, desc="Encoding images"):
+                # batch may be list of tensors or PIL
+                imgs = [
+                    F.to_pil_image(b.to(self.device))
+                    if not isinstance(b, Image.Image)
+                    else b
+                    for b in batch["image"]
+                ]
+                inputs = self.processor.process_images(imgs)
+                inputs = {k: v.to(self.device) for k, v in inputs.items()}
+                outs = self.encode_input(inputs)
+                all_embeds.extend(outs.cpu().to(torch.float32))
+
+        padded = torch.nn.utils.rnn.pad_sequence(
+            all_embeds, batch_first=True, padding_value=0
+        )
+        return padded
+
+    def get_text_embeddings(
+        self,
+        texts: DataLoader,
+        batch_size: int = 32,
+        **kwargs,
+    ) -> torch.Tensor:
+        all_embeds = []
+
+        with torch.no_grad():
+            for batch in tqdm(texts, desc="Encoding texts"):
+                batch_texts = batch["text"]
+                inputs = self.processor.process_queries(batch_texts)
+                inputs = {k: v.to(self.device) for k, v in inputs.items()}
+                outs = self.encode_input(inputs)
+                all_embeds.extend(outs.cpu().to(torch.float32))
+
+        padded = torch.nn.utils.rnn.pad_sequence(
+            all_embeds, batch_first=True, padding_value=0
+        )
+        return padded
+
+    def similarity(self, a: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
+        return self.processor.score_multi_vector(a, b, device=self.device)
+
+
+OPS_COLQWEN3_TRAINING_DATA = {
+    "VDRMultilingualRetrieval",
+    # from https://huggingface.co/datasets/vidore/colpali_train_set
+    "VidoreDocVQARetrieval",
+    "VidoreInfoVQARetrieval",
+    "VidoreTatdqaRetrieval",
+    "VidoreArxivQARetrieval",
+    "docmatix-ir",
+    "HotpotQA",
+    "FEVER",
+    "NQ",
+    "MIRACLRetrieval",
+    "WebInstructSub",  # MathStackExchange and ScienceStackExchange only
+    "MrTyDi",
+}
+
+multilingual_langs = [
+    "afr-Latn",
+    "ara-Arab",
+    "aze-Latn",
+    "bel-Cyrl",
+    "bul-Cyrl",
+    "ben-Beng",
+    "cat-Latn",
+    "ceb-Latn",
+    "ces-Latn",
+    "cym-Latn",
+    "dan-Latn",
+    "deu-Latn",
+    "ell-Grek",
+    "eng-Latn",
+    "spa-Latn",
+    "est-Latn",
+    "eus-Latn",
+    "fas-Arab",
+    "fin-Latn",
+    "fra-Latn",
+    "glg-Latn",
+    "guj-Gujr",
+    "heb-Hebr",
+    "hin-Deva",
+    "hrv-Latn",
+    "hat-Latn",
+    "hun-Latn",
+    "hye-Armn",
+    "ind-Latn",
+    "isl-Latn",
+    "ita-Latn",
+    "jpn-Jpan",
+    "jav-Latn",
+    "kat-Geor",
+    "kaz-Cyrl",
+    "khm-Khmr",
+    "kan-Knda",
+    "kor-Hang",
+    "kir-Cyrl",
+    "lao-Laoo",
+    "lit-Latn",
+    "lav-Latn",
+    "mkd-Cyrl",
+    "mal-Mlym",
+    "mon-Cyrl",
+    "mar-Deva",
+    "msa-Latn",
+    "mya-Mymr",
+    "nep-Deva",
+    "nld-Latn",
+    "nor-Latn",
+    "nob-Latn",
+    "nno-Latn",
+    "pan-Guru",
+    "pol-Latn",
+    "por-Latn",
+    "que-Latn",
+    "ron-Latn",
+    "rus-Cyrl",
+    "sin-Sinh",
+    "slk-Latn",
+    "slv-Latn",
+    "swa-Latn",
+    "tam-Taml",
+    "tel-Telu",
+    "tha-Thai",
+    "tgl-Latn",
+    "tur-Latn",
+    "ukr-Cyrl",
+    "urd-Arab",
+    "vie-Latn",
+    "yor-Latn",
+    "zho-Hans",
+]
+
+OPS_COLQWEN3_CITATION = """
+@misc{ops_colqwen3_4b,
+  author       = {OpenSearch-AI},
+  title        = {Ops-ColQwen3: State-of-the-Art Multimodal Embedding Model for Visual Document Retrieval},
+  year         = {2026},
+  url          = {https://huggingface.co/OpenSearch-AI/Ops-ColQwen3-4B},
+}"""
+
+ops_colqwen3_4b = ModelMeta(
+    loader=OpsColQwen3Wrapper,
+    name="OpenSearch-AI/Ops-Colqwen3-4B",
+    loader_kwargs=dict(dtype=torch.float16, trust_remote_code=True),
+    languages=multilingual_langs,
+    revision="4894b7d451ff33981650acc693bb482dbef302d3",
+    release_date="2026-01-24",
+    modalities=["image", "text"],
+    n_parameters=4_800_000_000,
+    memory_usage_mb=9206,
+    max_tokens=32768,
+    embed_dim=2560,
+    license="apache-2.0",
+    open_weights=True,
+    public_training_code="https://github.com/illuin-tech/colpali",
+    public_training_data=None,
+    framework=["PyTorch"],
+    reference="https://huggingface.co/OpenSearch-AI/Ops-Colqwen3-4B",
+    similarity_fn_name=ScoringFunction.MAX_SIM,
+    use_instructions=True,
+    training_datasets=OPS_COLQWEN3_TRAINING_DATA,
+    citation=OPS_COLQWEN3_CITATION,
+)

mteb/models/model_implementations/querit_models.py

@@ -0,0 +1,245 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+import torch
+from tqdm.auto import tqdm
+
+from mteb.models.model_meta import ModelMeta
+
+from .rerankers_custom import RerankerWrapper
+
+if TYPE_CHECKING:
+    from torch.utils.data import DataLoader
+
+    from mteb.abstasks.task_metadata import TaskMetadata
+    from mteb.types import BatchedInput, PromptType
+
+logger = logging.getLogger(__name__)
+
+
+class QueritWrapper(RerankerWrapper):
+    """
+    Multi-GPU / multi-process reranker wrapper for mteb.mteb evaluation.
+    Supports flattening all query-passage pairs without explicit grouping.
+    """
+
+    def __init__(
+        self,
+        model_name: str,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(model_name, **kwargs)
+        from transformers import AutoModel, AutoTokenizer
+
+        if not self.device:
+            self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        model_args = {}
+        if self.fp_options:
+            model_args["torch_dtype"] = self.fp_options
+        self.model = AutoModel.from_pretrained(
+            model_name, trust_remote_code=True, **model_args
+        )
+        logger.info(f"Using model {model_name}")
+
+        self.model.to(self.device)
+        self.tokenizer = AutoTokenizer.from_pretrained(
+            model_name, trust_remote_code=True
+        )
+        if "[CLS]" not in self.tokenizer.get_vocab():
+            raise ValueError("Tokenizer missing required special token '[CLS]'")
+        self.cls_token_id = self.tokenizer.convert_tokens_to_ids("[CLS]")
+        self.pad_token_id = self.tokenizer.pad_token_id or 0
+
+        self.max_length = (
+            min(kwargs.get("max_length", 4096), self.tokenizer.model_max_length) - 1
+        )  # sometimes it's a v large number/max int
+        logger.info(f"Using max_length of {self.max_length}, 1 token for [CLS]")
+        self.model.eval()
+
+    def process_inputs(
+        self,
+        pairs: list[str],
+    ) -> dict[str, torch.Tensor]:
+        """
+        Encode a batch of (query, document) pairs:
+        - Concatenate prompt + Query + Content
+        - Append [CLS] at the end
+        - Left-pad to max_length
+        - Generate custom attention mask based on block types
+        """
+        # Construct input texts
+        enc = self.tokenizer(
+            pairs,
+            add_special_tokens=False,
+            truncation=True,
+            max_length=self.max_length,
+            padding=False,
+        )
+
+        input_ids_list: list[list[int]] = []
+        attn_mask_list: list[torch.Tensor] = []
+
+        for ids in enc["input_ids"]:
+            # Append [CLS] token
+            ids = ids + [self.cls_token_id]
+            block_types = [1] * (len(ids) - 1) + [2]  # content + CLS
+
+            # Pad or truncate
+            if len(ids) < self.max_length:
+                pad_len = self.max_length - len(ids)
+                ids = [self.pad_token_id] * pad_len + ids
+                block_types = [0] * pad_len + block_types
+            else:
+                ids = ids[-self.max_length :]
+                block_types = block_types[-self.max_length :]
+
+            attn = self.compute_mask_content_cls(block_types)
+            input_ids_list.append(ids)
+            attn_mask_list.append(attn)
+
+        input_ids = torch.tensor(input_ids_list, dtype=torch.long, device=self.device)
+        attention_mask = torch.stack(attn_mask_list, dim=0).to(self.device)
+
+        return {"input_ids": input_ids, "attention_mask": attention_mask}
+
+    @torch.inference_mode()
+    def predict(
+        self,
+        inputs1: DataLoader[BatchedInput],
+        inputs2: DataLoader[BatchedInput],
+        *,
+        task_metadata: TaskMetadata,
+        hf_split: str,
+        hf_subset: str,
+        prompt_type: PromptType | None = None,
+        **kwargs: Any,
+    ) -> list[float]:
+        """
+        Predict relevance scores for query-passage pairs.
+        Supports both single-process and multi-process/multi-GPU modes.
+        """
+        # Flatten all pairs from mteb.mteb DataLoaders
+        queries = [text for batch in inputs1 for text in batch["text"]]
+        passages = [text for batch in inputs2 for text in batch["text"]]
+
+        instructions = None
+        if "instruction" in inputs2.dataset.features:
+            instructions = [text for batch in inputs1 for text in batch["instruction"]]
+
+        num_pairs = len(queries)
+        if num_pairs == 0:
+            return []
+        final_scores: list[float] = []
+
+        batch_size = kwargs.get("batch_size", self.batch_size)
+        with tqdm(total=num_pairs, desc="Scoring", ncols=100) as pbar:
+            for start in range(0, num_pairs, batch_size):
+                end = min(start + batch_size, num_pairs)
+                batch_q = queries[start:end]
+                batch_d = passages[start:end]
+
+                batch_instructions = (
+                    instructions[start:end]
+                    if instructions is not None
+                    else [None] * len(batch_q)
+                )
+                pairs = [
+                    self.format_instruction(instr, query, doc)
+                    for instr, query, doc in zip(batch_instructions, batch_q, batch_d)
+                ]
+                enc = self.process_inputs(pairs)
+                out = self.model(**enc)
+                scores = out["score"].squeeze(-1).detach().float().cpu().tolist()
+
+                if not isinstance(scores, list):
+                    scores = [scores]
+
+                final_scores.extend(scores)
+                pbar.update(len(scores))
+
+        return final_scores
+
+    @staticmethod
+    def format_instruction(instruction: str | None, query: str, doc: str) -> str:
+        if instruction is None:
+            output = f"Judge whether the Content meets the requirements based on the Query. Query: {query}; Content: {doc}"
+        else:
+            output = f"{instruction} Query: {query}; Content: {doc}"
+        return output
+
+    @staticmethod
+    def compute_mask_content_cls(block_types: list[int]) -> torch.Tensor:
+        """
+        Create custom attention mask based on token block types:
+        - 0: padding   → ignored
+        - 1: content   → causal attention to previous content only
+        - 2: [CLS]     → causal attention to all non-padding tokens
+
+        Args:
+            block_types: List of token types for one sequence
+
+        Returns:
+            [1, seq_len, seq_len] boolean attention mask (True = allowed to attend)
+        """
+        pos = torch.tensor(block_types, dtype=torch.long)
+        n = pos.shape[0]
+        if n == 0:
+            return torch.empty((0, 0), dtype=torch.bool, device=pos.device)
+
+        row_types = pos.view(n, 1)
+        col_types = pos.view(1, n)
+
+        row_idx = torch.arange(n, device=pos.device).view(n, 1)
+        col_idx = torch.arange(n, device=pos.device).view(1, n)
+        causal_mask = col_idx <= row_idx
+
+        # Content tokens only attend to previous content
+        mask_content = (row_types == 1) & (col_types == 1) & causal_mask
+
+        # [CLS] attends to all non-pad tokens (causal)
+        mask_cls = (row_types == 2) & (col_types != 0) & causal_mask
+
+        type_mask = mask_content | mask_cls
+        return type_mask.unsqueeze(0)
+
+
+querit_reranker_training_data = {
+    "MIRACLRanking",  # https://huggingface.co/datasets/mteb/MIRACLReranking
+    "MrTidyRetrieval",  # https://huggingface.co/datasets/mteb/mrtidy
+    "ruri-v3-dataset-reranker",  # https://huggingface.co/datasets/cl-nagoya/ruri-v3-dataset-reranker
+    "MultiLongDocReranking",  # https://huggingface.co/datasets/Shitao/MLDR
+    "MindSmallReranking",  # https://huggingface.co/datasets/mteb/MindSmallReranking
+    "MSMARCO",  # https://huggingface.co/datasets/mteb/msmarco
+    "CQADupStack",  # https://huggingface.co/datasets/mteb/cqadupstack-*
+    "AskUbuntuDupQuestions",  # https://github.com/taolei87/askubuntu & The corpus and queries that overlap with mteb/askubuntudupquestions-reranking have been removed.
+    "T2Reranking",  # https://huggingface.co/datasets/THUIR/T2Ranking & The corpus and queries that overlap with mteb/T2Reranking have been removed.
+}
+
+model_meta = ModelMeta(
+    loader=QueritWrapper,
+    loader_kwargs={
+        "fp_options": "bfloat16",
+    },
+    name="Querit/Querit",
+    model_type=["cross-encoder"],
+    languages=["eng-Latn"],
+    open_weights=True,
+    revision="5ad2649cc4defb7e1361262260e9a781f14b08bc",
+    release_date="2026-01-24",
+    n_parameters=4919636992,
+    n_embedding_parameters=131907584,
+    embed_dim=1024,
+    memory_usage_mb=9383.0,
+    max_tokens=4096,
+    reference="https://huggingface.co/Querit/Querit",
+    similarity_fn_name=None,
+    training_datasets=querit_reranker_training_data,
+    license="apache-2.0",
+    framework=["PyTorch"],
+    use_instructions=None,
+    public_training_code=None,
+    public_training_data=None,
+    citation=None,
+)

{mteb-2.7.12.dist-info → mteb-2.7.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mteb
-Version: 2.7.12
+Version: 2.7.13
 Summary: Massive Text Embedding Benchmark
 Author-email: MTEB Contributors <niklas@huggingface.co>, Kenneth Enevoldsen <kenneth.enevoldsen@cas.au.dk>, Nouamane Tazi <nouamane@huggingface.co>, Nils Reimers <info@nils-reimers.de>
 Maintainer-email: Kenneth Enevoldsen <kenneth.enevoldsen@cas.au.dk>, Roman Solomatin <risolomatin@gmail.com>, Isaac Chung <chungisaac1217@gmail.com>
@@ -32,8 +32,6 @@ Requires-Dist: rich>=0.0.0
 Requires-Dist: pytrec-eval-terrier>=0.5.6
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: polars>=0.20.22
-Requires-Dist: torch; python_full_version < "3.14"
-Requires-Dist: torch>=2.9.0; python_full_version >= "3.14"
 Provides-Extra: image
 Requires-Dist: torchvision>0.2.1; extra == "image"
 Requires-Dist: transformers[torch-vision,vision]; extra == "image"

{mteb-2.7.12.dist-info → mteb-2.7.13.dist-info}/RECORD

@@ -1565,14 +1565,15 @@ mteb/models/model_implementations/model2vec_models.py,sha256=qXcPhV0hGRFBsvRBrb8
 mteb/models/model_implementations/moka_models.py,sha256=4Esujv_fVJjHuX1nRH6sGtmrmF04A90F4Xo2uN0YTzs,5205
 mteb/models/model_implementations/nbailab.py,sha256=iv2xdqVM5HoTAlBR6e_UdzJu6rSPujqWXFYwyCv69hU,2684
 mteb/models/model_implementations/no_instruct_sentence_models.py,sha256=DTb-eHZYSY6lGJkkdkC0tZ_n0GHLQwVlUehVg59T5N4,4198
-mteb/models/model_implementations/nomic_models.py,sha256=oUaSabKEJXrg_cnmWdfczsdrqRDP7LZhX5vN1U5b-Xk,15469
+mteb/models/model_implementations/nomic_models.py,sha256=BO6XQbX4PFa5By0opAYkxz95CcHmjxbG5DYcklxJ1l8,16986
 mteb/models/model_implementations/nomic_models_vision.py,sha256=AzTCWbXBonUAVub0TTxWCsBtg4WYex3vPiLlz3ULdHc,6916
-mteb/models/model_implementations/nvidia_llama_nemoretriever_colemb.py,sha256=5jYzS0qc4x82T5_c1HFt4uy9kksTt9Fs24pdLioq4Oc,7033
+mteb/models/model_implementations/nvidia_llama_nemoretriever_colemb.py,sha256=-5_kd9jeDcgVv9gdwWuvX_-bNQdhAxInf1Mqo8_BdS8,10653
 mteb/models/model_implementations/nvidia_models.py,sha256=r-AW1dVQbteWjexjvZgFEt_90OHNRYer_5GLuqSXRS0,26924
 mteb/models/model_implementations/octen_models.py,sha256=5z-t2O-iIFiOOLdZ_AK9f7GrVRg-9_vx3JNAG9dJNPE,8562
 mteb/models/model_implementations/openai_models.py,sha256=y1wMknrrcu1L5CNwniG0mFThPVMON1c2Fj22jkKsw7Y,9730
 mteb/models/model_implementations/openclip_models.py,sha256=z2gQum16O0QhJPyxqKor3oO-_uWfnep6wSXqOFQQ2Q8,11969
 mteb/models/model_implementations/opensearch_neural_sparse_models.py,sha256=O6ewgGKZtw-kpspbz8-dXArDf5tUWy_vY6AxFs7fsZ8,8936
+mteb/models/model_implementations/ops_colqwen3_models.py,sha256=5vg5d1_WfVGMgtIwkh6zf2-Paum6V35XcKEvLfRyRzs,7437
 mteb/models/model_implementations/ops_moa_models.py,sha256=Ah7L78mqC9pH8t6sf1OWXOLjouVUpAutt6lZ0np7eMM,2655
 mteb/models/model_implementations/ordalietech_solon_embeddings_mini_beta_1_1.py,sha256=xv1ftJeMND4lpeKYC3RLQB4nhdiYy0wCxrzEjUj4gSg,1114
 mteb/models/model_implementations/pawan_models.py,sha256=iyzh6NSPZKU9znJYEDPjJNIqvkyuKPAol5TcILuq1Is,1225
@@ -1582,6 +1583,7 @@ mteb/models/model_implementations/promptriever_models.py,sha256=tDXysEKbvoDNtidV
 mteb/models/model_implementations/pylate_models.py,sha256=EwpDJf5yjONmmiv9zHSEbc3e7kMRJUHYv7K59QTrNAE,17525
 mteb/models/model_implementations/qodo_models.py,sha256=AwYRGctJbjEkcIh1pcSeeEXYiYiizAbfTyw6CaZBJfU,2224
 mteb/models/model_implementations/qtack_models.py,sha256=vw_2O4ZABR-_nYV4g1Ud8bW1DTP-wwtQS2eGqN70vT4,1304
+mteb/models/model_implementations/querit_models.py,sha256=P7lAw5IDe47DA_5srMwGPqxjMIFuvOW0BJ7xwB4GOro,8917
 mteb/models/model_implementations/qwen3_models.py,sha256=857UnUEil9o8xcw7vSr2fMRlEegyE2Q86e5yLeRL_mQ,5517
 mteb/models/model_implementations/qzhou_models.py,sha256=mfG70JrNJCo-s3MykRn6lg9gFPcKMeMI7Y8VrBhNo7I,3684
 mteb/models/model_implementations/random_baseline.py,sha256=YsITQoLbea_Iz2X84WNGBGkhlsQ3hB7yx1oJwXghimE,7561
@@ -2644,9 +2646,9 @@ mteb/types/_metadata.py,sha256=NN-W0S6a5TDV7UkpRx1pyWtGF4TyyCyoPUfHOwdeci8,2290
 mteb/types/_result.py,sha256=UKNokV9pu3G74MGebocU512aU_fFU9I9nPKnrG9Q0iE,1035
 mteb/types/_string_validators.py,sha256=PY-dYq4E8O50VS3bLYdldPWp400fl_WzUjfVSkNWe8U,523
 mteb/types/statistics.py,sha256=gElgSShKBXpfcqaZHhU_d2UHln1CyzUj8FN8KFun_UA,4087
-mteb-2.7.12.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-mteb-2.7.12.dist-info/METADATA,sha256=qFfnF_lPdIQWnBIiunbaPAatQI_x21ouRUpgasLHbM0,14458
-mteb-2.7.12.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-mteb-2.7.12.dist-info/entry_points.txt,sha256=8IJoEJFKoDHmVnNev-qJ9pp4Ln7_1-ma9QsXnzVCzGU,39
-mteb-2.7.12.dist-info/top_level.txt,sha256=OLVIjcQAlWBz0bdmutKlWHLF42FF0hp4uVAg3ZyiG4U,5
-mteb-2.7.12.dist-info/RECORD,,
+mteb-2.7.13.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+mteb-2.7.13.dist-info/METADATA,sha256=Fy5yLv2nllzE1LSF6S33tHCnWsaiGZzI5HTEUC02ufU,14348
+mteb-2.7.13.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+mteb-2.7.13.dist-info/entry_points.txt,sha256=8IJoEJFKoDHmVnNev-qJ9pp4Ln7_1-ma9QsXnzVCzGU,39
+mteb-2.7.13.dist-info/top_level.txt,sha256=OLVIjcQAlWBz0bdmutKlWHLF42FF0hp4uVAg3ZyiG4U,5
+mteb-2.7.13.dist-info/RECORD,,