first commit

CONTRIBUTING

@@ -0,0 +1,3 @@
+TODO: add tests and commit hooks
+
+Users must be sure no files are over 10MB. If there are we should remove all spaces from them to keep them < 10MB. This should be a pre-commit hook checking.

README.md

@@ -0,0 +1,25 @@
+---
+benchmark: mteb
+type: evaluation
+submission_name: MTEB
+---
+
+> [!NOTE]  
+> Previously it was possible to submit models results to MTEB by adding the results to the model metadata. This is no longer an option as we want to ensure high quality metadata.
+
+
+This repository contains the results of the embedding benchmark evaluated using the package `mteb`.
+
+
+| Reference           |                                                                                          |
+| ------------------- | ---------------------------------------------------------------------------------------- |
+| 🦾 **[Leaderboard]** | An up to date leaderboard of embedding models                                            |
+| 📚 **[mteb]**        | Guides and instructions on how to use `mteb`, including running, submitting scores, etc. |
+| 🙋 **[Questions]**   | Questions about the results                                                              |
+| 🙋 **[Issues]**      | Issues or bugs you have found                                                            |
+
+
+[Leaderboard]: https://huggingface.co/spaces/mteb/leaderboard
+[mteb]: https://github.com/embeddings-benchmark/mteb
+[Questions]: https://github.com/embeddings-benchmark/mteb/discussions
+[Issues]: https://github.com/embeddings-benchmark/mteb/issues

load_external.py

@@ -0,0 +1,253 @@
+from __future__ import annotations
+
+import json
+import logging
+import math
+import re
+from pathlib import Path
+from typing import Any
+
+from huggingface_hub import HfApi, get_hf_file_metadata, hf_hub_download, hf_hub_url
+from huggingface_hub.errors import NotASafetensorsRepoError
+from huggingface_hub.hf_api import ModelInfo
+from huggingface_hub.repocard import metadata_load
+from mteb import ModelMeta, get_task
+
+API = HfApi()
+logger = logging.getLogger(__name__)
+
+
+library_mapping = {
+    "sentence-transformers": "Sentence Transformers",
+}
+
+
+def get_model_dir(model_id: str) -> Path:
+    external_result_dir = Path("results") / model_id.replace("/", "__") / "external"
+    return external_result_dir
+
+
+renamed_tasks = {
+    "NorwegianParliament": "NorwegianParliamentClassification",
+    "CMedQAv2": "CMedQAv2-reranking",
+    "CMedQAv1": "CMedQAv1-reranking",
+    "8TagsClustering": "EightTagsClustering",
+    "PPC": "PpcPC",
+    "PawsX": "PawsXParaphraseIdentification",
+}
+
+
+def simplify_dataset_name(name: str) -> str:
+    task_name = name.replace("MTEB ", "").split()[0]
+    return renamed_tasks.get(task_name, task_name)
+
+
+def get_model_parameters_memory(model_info: ModelInfo) -> tuple[int| None, float|None]:
+    try:
+        safetensors = API.get_safetensors_metadata(model_info.id)
+        num_parameters = sum(safetensors.parameter_count.values())
+        return num_parameters, round(num_parameters * 4 / 1024 ** 3, 2)
+    except NotASafetensorsRepoError as e:
+        logger.info(f"Could not find SafeTensors metadata for {model_info.id}")
+
+    filenames = [sib.rfilename for sib in model_info.siblings]
+    if "pytorch_model.bin" in filenames:
+        url = hf_hub_url(model_info.id, filename="pytorch_model.bin")
+        meta = get_hf_file_metadata(url)
+        bytes_per_param = 4
+        num_params = round(meta.size / bytes_per_param)
+        size_gb = round(meta.size * (4 / bytes_per_param) / 1024 ** 3, 2)
+        return num_params, size_gb
+    if "pytorch_model.bin.index.json" in filenames:
+        index_path = hf_hub_download(model_info.id, filename="pytorch_model.bin.index.json")
+        size = json.load(open(index_path))
+        bytes_per_param = 4
+        if "metadata" in size and "total_size" in size["metadata"]:
+            return round(size["metadata"]["total_size"] / bytes_per_param), round(size["metadata"]["total_size"] / 1024 ** 3, 2)
+    logger.info(f"Could not find the model parameters for {model_info.id}")
+    return None, None
+
+
+def get_dim_seq_size(model: ModelInfo) -> tuple[str | None, str | None, int, float]:
+    siblings = model.siblings or []
+    filenames = [sib.rfilename for sib in siblings]
+    dim, seq = None, None
+    for filename in filenames:
+        if re.match(r"\d+_Pooling/config.json", filename):
+            st_config_path = hf_hub_download(model.id, filename=filename)
+            dim = json.load(open(st_config_path)).get("word_embedding_dimension", None)
+            break
+    for filename in filenames:
+        if re.match(r"\d+_Dense/config.json", filename):
+            st_config_path = hf_hub_download(model.id, filename=filename)
+            dim = json.load(open(st_config_path)).get("out_features", dim)
+    if "config.json" in filenames:
+        config_path = hf_hub_download(model.id, filename="config.json")
+        config = json.load(open(config_path))
+        if not dim:
+            dim = config.get("hidden_dim", config.get("hidden_size", config.get("d_model", None)))
+        seq = config.get("n_positions", config.get("max_position_embeddings", config.get("n_ctx", config.get("seq_length", None))))
+
+    parameters, memory = get_model_parameters_memory(model)
+    return dim, seq, parameters, memory
+
+
+def create_model_meta(model_info: ModelInfo) -> ModelMeta | None:
+    readme_path = hf_hub_download(model_info.id, filename="README.md", etag_timeout=30)
+    meta = metadata_load(readme_path)
+    dim, seq, parameters, memory = None, None, None, None
+    try:
+        dim, seq, parameters, memory = get_dim_seq_size(model_info)
+    except Exception as e:
+        logger.error(f"Error getting model parameters for {model_info.id}, {e}")
+
+    release_date = str(model_info.created_at.date()) if model_info.created_at else ""
+    library = [library_mapping[model_info.library_name]] if model_info.library_name in library_mapping else []
+    languages = meta.get("language", [])
+    if not isinstance(languages, list) and isinstance(languages, str):
+        languages = [languages]
+    # yaml transforms norwegian `no` to False
+    for i in range(len(languages)):
+        if languages[i] is False:
+            languages[i] = "no"
+
+    model_meta = ModelMeta(
+        name=model_info.id,
+        revision=model_info.sha,
+        release_date=release_date,
+        open_weights=True,
+        framework=library,
+        license=meta.get("license", None),
+        embed_dim=dim,
+        max_tokens=seq,
+        n_parameters=parameters,
+        languages=languages,
+    )
+    return model_meta
+
+
+def parse_readme(model_info: ModelInfo) -> dict[str, dict[str, Any]] | None:
+    model_id = model_info.id
+    try:
+        readme_path = hf_hub_download(model_info.id, filename="README.md", etag_timeout=30)
+    except Exception:
+        logger.warning(f"ERROR: Could not fetch metadata for {model_id}, trying again")
+        readme_path = hf_hub_download(model_id, filename="README.md", etag_timeout=30)
+    meta = metadata_load(readme_path)
+    if "model-index" not in meta:
+        logger.info(f"Could not find model-index in {model_id}")
+        return
+    model_index = meta["model-index"][0]
+    model_name_from_readme = model_index.get("name", None)
+    orgs = ["Alibaba-NLP", "HIT-TMG", "McGill-NLP", "Snowflake", "facebook", "jinaai", "nomic-ai"]
+    is_org = any([model_id.startswith(org) for org in orgs])
+    # There a lot of reuploads with tunes, quantization, etc. We only want the original model
+    # to prevent this most of the time we can check if the model name from the readme is the same as the model id
+    # but some orgs have a different naming in their readme
+    if model_name_from_readme and not model_info.id.endswith(model_name_from_readme) and not is_org:
+        logger.warning(f"Model name mismatch: {model_info.id} vs {model_name_from_readme}")
+        return
+    results = model_index.get("results", [])
+    model_results = {}
+    for result in results:
+        dataset = result["dataset"]
+        dataset_type = simplify_dataset_name(dataset["name"])
+
+        if dataset_type not in model_results:
+            output_dict = {
+                "dataset_revision": dataset.get("revision", ""),
+                "task_name": simplify_dataset_name(dataset["name"]),
+                "evaluation_time": None,
+                "mteb_version": None,
+                "scores": {},
+            }
+        else:
+            output_dict = model_results[dataset_type]
+
+        try:
+            mteb_task = get_task(output_dict["task_name"])
+        except Exception:
+            logger.warning(f"Error getting task for {model_id} {output_dict['task_name']}")
+            continue
+
+        mteb_task_metadata = mteb_task.metadata
+        mteb_task_eval_languages = mteb_task_metadata.eval_langs
+
+        scores_dict = output_dict["scores"]
+        current_split = dataset["split"]
+        current_config = dataset.get("config", "")
+        cur_split_metrics = {
+            "hf_subset": current_config,
+            "languages": mteb_task_eval_languages if isinstance(mteb_task_eval_languages, list) else mteb_task_eval_languages.get(current_config, ["None"]),
+        }
+        for metric in result["metrics"]:
+            if isinstance(metric["value"], (float, int)):
+                cur_split_metrics[metric["type"]] = metric["value"] / 100
+            else:
+                cur_split_metrics[metric["type"]] = metric["value"]
+
+        main_score_str = "main_score"
+        if main_score_str not in cur_split_metrics:
+            # old sts and sum_eval have cos_sim_pearson, but in model_meta cosine_spearman is main_score
+            for old_metric, new_metric in zip(["cos_sim_pearson", "cos_sim_spearman"], ["cosine_pearson", "cosine_spearman"]):
+                if old_metric in cur_split_metrics:
+                    cur_split_metrics[new_metric] = cur_split_metrics[old_metric]
+
+            if mteb_task.metadata.main_score not in cur_split_metrics:
+                logger.warning(f"Could not find main score for {model_id} {output_dict['task_name']}, mteb task {mteb_task.metadata.name}. Main score: {mteb_task.metadata.main_score}. Metrics: {cur_split_metrics}, result {result['metrics']}")
+                continue
+
+            cur_split_metrics[main_score_str] = cur_split_metrics.get(mteb_task.metadata.main_score, None)
+        split_metrics = scores_dict.get(current_split, [])
+        split_metrics.append(cur_split_metrics)
+        scores_dict[current_split] = split_metrics
+        model_results[dataset_type] = output_dict
+    return model_results
+
+
+def get_mteb_data() -> None:
+    models = sorted(list(API.list_models(filter="mteb", full=True)), key=lambda x: x.id)
+    # models = [model for model in models if model.id == "ai-forever/ru-en-RoSBERTa"]
+    for i, model_info in enumerate(models, start=1):
+        logger.info(f"[{i}/{len(models)}] Processing {model_info.id}")
+        model_path = get_model_dir(model_info.id)
+        if (model_path / "model_meta.json").exists() and len(list(model_path.glob("*.json"))) > 1:
+            logger.info(f"Model meta already exists for {model_info.id}")
+            # continue
+        if model_info.id.lower().endswith("gguf"):
+            logger.info(f"Skipping {model_info.id} GGUF model")
+            continue
+
+        spam_users = ["ILKT", "fine-tuned", "mlx-community"]
+        is_spam = False
+        for spam_user in spam_users:
+            if model_info.id.startswith(spam_user):
+                logger.info(f"Skipping {model_info.id}")
+                is_spam = True
+                continue
+        if is_spam:
+            continue
+        model_meta = create_model_meta(model_info)
+        model_results = parse_readme(model_info)
+
+        if not model_meta or not model_results:
+            logger.warning(f"Could not get model meta or results for {model_info.id}")
+            continue
+
+        if not model_path.exists():
+            model_path.mkdir(parents=True, exist_ok=True)
+
+        model_meta_path = model_path / "model_meta.json"
+        with model_meta_path.open("w") as f:
+            json.dump(model_meta.model_dump(), f, indent=4)
+
+        for model_result in model_results:
+            task_name = model_results[model_result]["task_name"]
+            result_file = model_path / f"{task_name}.json"
+            with result_file.open("w") as f:
+                json.dump(model_results[model_result], f, indent=4)
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    get_mteb_data()

makefile

@@ -0,0 +1,12 @@
+install-for-tests:
+	@echo "--- Installing dependencies for tests ---"
+	pip install pip --upgrade
+	pip install .
+
+test:
+	@echo "--- Running tests ---"
+	pytest
+
+pre-push:
+	@echo "--- Running pre-push commands ---"
+	python reduce_large_json_files.py

pyproject.toml

@@ -0,0 +1,7 @@
+[project]
+name = "results"
+version = "0.1.0"
+description = "The result repository for mteb"
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = ["mteb[dev]>=1.13.0"]

reduce_large_json_files.py

@@ -0,0 +1,43 @@
+import glob
+import json
+import os
+from pathlib import Path
+
+import mteb
+
+
+def resize_flores():
+    """
+    includes only relevant splits from the FloresBitextMining.json files
+    """
+    paths = Path(__file__).parent.glob("**/FloresBitextMining.json")
+
+    for p in paths:
+        try:
+            res = mteb.MTEBResults.from_disk(p)
+            res.validate_and_filter_scores()
+            res.to_disk(p)
+        except Exception:
+            pass
+
+
+def remove_spaces():
+    """
+    removes spaces from the json files
+    """
+
+    for file in glob.glob("results/*/*/*.json"):
+        # if the file is greater than 9 MB, compress it with gzip
+        if os.path.getsize(file) >= 9.5 * 1024 * 1024:
+            print(f"Resizing {file} to have no indentations")
+            # read it in as json and write it out with no indent
+            with open(file, "r") as f:
+                data = json.load(f)
+
+            with open(file, "w") as f:
+                json.dump(data, f, indent=None)
+
+
+if __name__ == "__main__":
+    resize_flores()
+    remove_spaces()

scripts/convert_bright.py

@@ -0,0 +1,83 @@
+import json
+import os
+
+REPLACE_MAP = {
+    "NDCG": "ndcg",
+    "MAP": "map",
+    "MRR": "mrr",
+    "RECALL": "recall",
+    "Recall": "recall",
+    "P": "precision",
+}
+
+MODEL_TO_MODEL = {
+    "bm25": "bm25",
+    "bge": "bge-large-en-v1.5",
+    "cohere": "Cohere-embed-english-v3.0",
+    "e5": "e5-mistral-7b-instruct",
+    "google": "google-gecko.text-embedding-preview-0409",
+    "grit": "GritLM-7B",
+    "inst-l": "instructor-large",
+    "inst-xl": "instructor-xl",
+    "openai": "text-embedding-3-large",
+    "qwen2": "gte-Qwen2-7B-instruct",
+    "qwen": "gte-Qwen1.5-7B-instruct",
+    "sbert": "all-mpnet-base-v2",
+    "sf": "SFR-Embedding-Mistral",
+    "voyage": "voyage-large-2-instruct",
+}
+folders = os.listdir("bright_scores/main") + os.listdir("bright_scores/long_context")
+models = set(
+    [
+        x.split("_")[-3]
+        for x in folders
+        if (os.path.isdir("bright_scores/main/" + x) or os.path.isdir("bright_scores/long_context/" + x))
+    ]
+)
+print(models)
+for model in models:
+    print(f"Converting {model}")
+    result_template = {
+        "dataset_revision": "a75a0eb483f6a5233a6efc2d63d71540a4443dfb",
+        "evaluation_time": 0,
+        "kg_co2_emissions": None,
+        "mteb_version": "1.12.79",
+        "scores": {"standard": [], "long": []},
+        "task_name": "BrightRetrieval",
+    }
+    for folder in [
+        x
+        for x in folders
+        if (os.path.isdir("bright_scores/main/" + x) or os.path.isdir("bright_scores/long_context/" + x))
+        and (x.split("_")[-3] == model)
+    ]:
+        if os.path.isdir("bright_scores/main/" + folder):
+            results_path = os.path.join("bright_scores/main", folder, "results.json")
+            split = "standard"
+        else:
+            results_path = os.path.join("bright_scores/long_context", folder, "results.json")
+            assert "long_True" in folder, folder
+            split = "long"
+
+        with open(results_path) as f:
+            results = json.load(f)
+
+        if len(folder.split("_")) == 4:
+            subset = folder.split("_")[0]
+        elif len(folder.split("_")) == 5:
+            subset = folder.split("_")[0] + "_" + folder.split("_")[1]
+
+        result_template["scores"][split].append(
+            {
+                "hf_subset": subset,
+                "languages": ["eng-Latn"],
+                "main_score": results["NDCG@10"],
+                **{"_at_".join([REPLACE_MAP.get(x, x) for x in k.split("@")]): v for k, v in results.items()},
+            }
+        )
+
+    model_folder = MODEL_TO_MODEL[model]
+    os.makedirs(f"results/{model_folder}/no_revision_available", exist_ok=True)
+    print(f"Writing to: results/{model_folder}/no_revision_available/BrightRetrieval.json")
+    with open(f"results/{model_folder}/no_revision_available/BrightRetrieval.json", "w") as f:
+        json.dump(result_template, f, indent=4)

scripts/merge_same_model.py

@@ -0,0 +1,46 @@
+import os
+import glob
+import tqdm
+
+
+def line_count(file):
+    with open(file) as f:
+        return sum(1 for _ in f)
+
+
+for folder in glob.glob("results/*"):
+    if not os.path.isdir(folder):
+        continue
+
+    print(f"Processing {folder}")
+
+    # create the subfolder if it doesn't exist
+    for subfolder in glob.glob(os.path.join(folder + "-1", "*")):
+        if not os.path.isdir(subfolder):
+            continue
+
+        # if it doesn't exist in the original, create it
+        if not os.path.isdir(subfolder.replace("-1", "")):
+            os.makedirs(subfolder.replace("-1", ""), exist_ok=True)
+
+    # if there is the same folder name but with -1 at the end, we need a merge
+    if os.path.isdir(folder + "-1"):
+        # copy each file over, unless it is already there, in which case choose the longest one
+        for file in tqdm.tqdm(glob.glob(os.path.join(folder + "-1", "*", "*.json"))):
+            if os.path.exists(file.replace("-1", "")):
+                line_count_1 = line_count(file)
+                line_count_2 = line_count(file.replace("-1", ""))
+                if line_count_1 > line_count_2:
+                    os.system(f"mv {file} {file.replace('-1', '')}")
+
+            else:
+                os.system(f"mv {file} {file.replace('-1', '')}")
+
+
+"""
+This script merges two model directories that are the same except one ends with "-1"
+
+I renamed all files to end with "-1" because we can't have duplicate filenames. Then we need some script to merge their contents (which is this). So first rename all model folders then run this. 
+
+Then go through and remove the -1 from ones that are new and thus werent merged
+"""

scripts/normalize_results_folder.py

@@ -0,0 +1,128 @@
+"""Normalize folder structure for the results folder such that results are on the same format as the mteb run command."""
+
+import json
+import logging
+from pathlib import Path
+
+import mteb
+from packaging.version import Version
+from tqdm import tqdm
+
+logger = logging.getLogger(__name__)
+
+
+def resolve_conflict_meta(current_path: Path, expected_path: Path) -> None:
+    """Resolve conflict between two meta files."""
+    with current_path.open("r") as f:
+        current_meta = json.load(f)
+
+    with expected_path.open("r") as f:
+        expected_meta = json.load(f)
+
+    if current_meta == expected_meta:
+        logger.info("Meta file is the same, removing")
+        current_path.unlink()
+    else:
+        logger.info("Meta file is different, please resolve manually.")
+
+
+def resolve_conflict_result(current_path: Path, expected_path: Path) -> None:
+    """Resolve conflict between two result files."""
+    c_res = mteb.MTEBResults.from_disk(current_path)
+    e_res = mteb.MTEBResults.from_disk(expected_path)
+    c_dict_repr = c_res.model_dump()
+    e_dict_repr = e_res.model_dump()
+
+    for d in [c_dict_repr, e_dict_repr]:
+        d.pop("kg_co2_emissions")
+        d.pop("evaluation_time")
+
+    if c_dict_repr == e_dict_repr:
+        logger.info("Result file is the same, removing")
+        current_path.unlink()
+    else:
+        # check version and keep the newest
+        c_version = c_res.mteb_version
+        e_version = e_res.mteb_version
+
+        if Version(c_version) > Version(e_version):
+            logger.info("Newer version of result file, moving")
+            expected_path.parent.mkdir(parents=True, exist_ok=True)
+            current_path.rename(expected_path)
+        elif Version(c_version) == Version(e_version):
+            logger.info("Same version of result file, removing, but scores are different. Please resolve manually.")
+            logger.info(f"Old scores: {c_res.scores}")
+            logger.info(f"New scores: {e_res.scores}")
+        else:
+            logger.info("Older version of result file, removing")
+            # make sure the folder exists
+            current_path.unlink()
+
+
+def resolve_conflict(current_path: Path, expected_path: Path) -> None:
+    """Resolve conflict between two files."""
+    if current_path.name == "model_meta.json":
+        resolve_conflict_meta(current_path, expected_path)
+    else:
+        resolve_conflict_result(current_path, expected_path)
+
+
+def remove_folders_with_only_meta_files(results_folder: Path) -> None:
+    """Remove folders that only contain a meta file."""
+    for folder in results_folder.glob("*/*"):
+        if len(list(folder.glob("*.json"))) == 1:
+            meta_file = list(folder.glob("*.json"))[0]
+            if meta_file.name == "model_meta.json":
+                logger.info(f"Removing folder {folder}")
+                meta_file.unlink()
+                folder.rmdir()
+
+
+def main(attempt_to_resolve_conflict: bool) -> None:
+    """Main function."""
+    results_folder = Path(__file__).parent.parent / "results"
+    meta_files = results_folder.glob("**/model_meta.json")
+    meta_files = list(meta_files)
+
+    conflict_encountered = False
+
+    for meta_file in tqdm(meta_files):
+        with open(meta_file, "r") as f:
+            meta = json.load(f)
+
+        mdl_name, revision = meta["name"], meta["revision"]
+
+        mdl_name = mdl_name.replace(" ", "_").replace("/", "__")
+
+        if revision is None:
+            revision = meta_file.parent.name
+
+        expected_path = results_folder / mdl_name / revision
+        if expected_path != meta_file.parent:
+            logger.info(f"Moving {meta_file.parent}/*.json to {expected_path}")
+
+            files_in_folder = meta_file.parent.glob("*.json")
+
+            for file in files_in_folder:
+                if (expected_path / file.name).exists():
+                    conflict_encountered = True
+                    logger.info(f"File {file} already exists in {expected_path}")
+                    if attempt_to_resolve_conflict is True:
+                        resolve_conflict(file, expected_path / file.name)
+                else:
+                    # make sure the folder exists
+                    expected_path.mkdir(parents=True, exist_ok=True)
+                    file.rename(expected_path / file.name)
+
+    if conflict_encountered and not attempt_to_resolve_conflict:
+        raise Exception("Conflicts encountered.")
+
+    remove_folders_with_only_meta_files(results_folder)
+
+
+if __name__ == "__main__":
+    logging.basicConfig(
+        level=logging.INFO,
+    )
+
+    main(attempt_to_resolve_conflict=True)

scripts/remove_ablations.py

@@ -0,0 +1,17 @@
+import glob
+import os
+import json
+import tqdm
+
+
+for file in tqdm.tqdm(glob.glob("results/*/*.json")):
+    print(file)
+    if "Instruction" not in file:
+        continue
+    with open(file, "r") as fin:
+        data = json.load(fin)
+        if "individual" in data["test"]:
+            del data["test"]["individual"]
+
+    with open(file, "w") as fout:
+        json.dump(data, fout, indent=2)

tests/mock_cache_dir/readme.md

@@ -0,0 +1 @@
+this is just a mock cache directory, which implements a folder with a link to the results folder in root.

tests/mock_cache_dir/results/results

@@ -0,0 +1 @@
+../../../results

tests/test_correct_folder_structure.py

@@ -0,0 +1,287 @@
+import json
+from pathlib import Path
+
+import pytest
+
+results_folder = Path(__file__).parent.parent / "results"
+
+
+def get_metafiles():
+    meta_files = results_folder.glob("**/model_meta.json")
+    meta_files = list(meta_files)
+    return meta_files
+
+
+@pytest.mark.parametrize("meta_file", get_metafiles())
+def test_correct_folder_structure(meta_file):
+    """
+    the folders should be structured as follows:
+    results/model_name/revision/*json
+    """
+
+    with meta_file.open("r") as f:
+        meta = json.load(f)
+
+    mdl_name, revision = meta["name"], meta["revision"]
+
+    mdl_name = mdl_name.replace(" ", "_").replace("/", "__")
+
+    if revision is None:
+        revision = meta_file.parent.name
+
+    if meta_file.parent.parts[-1] == "external":
+        revision = "external"
+
+    expected_path = results_folder / mdl_name / revision
+    assert expected_path == meta_file.parent
+    assert expected_path.exists()
+    assert len(list(expected_path.glob("*.json"))) > 0
+    for file in expected_path.glob("*.json"):
+        assert file.exists()
+        assert file.is_file()
+        assert file.parent == expected_path
+        assert file.suffix == ".json"
+
+
+folders_without_meta = [  # please do not add to this list it is only intended for backwards compatibility. Future results should have a model_meta.json file
+    ("Alibaba-NLP__gte-Qwen1.5-7B-instruct", "no_revision_available"),
+    ("Alibaba-NLP__gte-Qwen2-7B-instruct", "no_revision_available"),
+    ("BAAI__bge-base-en", "no_revision_available"),
+    ("BAAI__bge-base-en-v1.5-instruct", "a5beb1e3e68b9ab74eb54cfd186867f64f240e1a"),
+    ("BAAI__bge-base-zh", "no_revision_available"),
+    ("BAAI__bge-base-zh-v1.5", "no_revision_available"),
+    ("BAAI__bge-large-en", "no_revision_available"),
+    ("BAAI__bge-large-en-v1.5", "no_revision_available"),
+    ("BAAI__bge-large-en-v1.5-instruct", "d4aa6901d3a41ba39fb536a557fa166f842b0e09"),
+    ("BAAI__bge-large-zh", "no_revision_available"),
+    ("BAAI__bge-large-zh-noinstruct", "no_revision_available"),
+    ("BAAI__bge-large-zh-v1.5", "no_revision_available"),
+    ("BAAI__bge-m3", "no_revision_available"),
+    ("BAAI__bge-m3-instruct", "5617a9f61b028005a4858fdac845db406aefb181"),
+    ("BAAI__bge-small-en-v1.5-instruct", "5c38ec7c405ec4b44b94cc5a9bb96e735b38267a"),
+    ("BAAI__bge-small-zh", "no_revision_available"),
+    ("BAAI__bge-small-zh-v1.5", "no_revision_available"),
+    ("Cohere__Cohere-embed-english-v3.0", "no_revision_available"),
+    ("Cohere__Cohere-embed-english-v3.0-instruct", "no_revision_available"),
+    ("Cohere__Cohere-embed-multilingual-light-v3.0", "no_revision_available"),
+    ("Cohere__Cohere-embed-multilingual-v3.0", "no_revision_available"),
+    ("FacebookAI__xlm-roberta-base", "no_revision_available"),
+    ("FacebookAI__xlm-roberta-large", "no_revision_available"),
+    ("Geotrend__bert-base-10lang-cased", "no_revision_available"),
+    ("Geotrend__bert-base-15lang-cased", "no_revision_available"),
+    ("Geotrend__bert-base-25lang-cased", "no_revision_available"),
+    ("Geotrend__distilbert-base-25lang-cased", "no_revision_available"),
+    ("Geotrend__distilbert-base-en-fr-cased", "no_revision_available"),
+    ("Geotrend__distilbert-base-en-fr-es-pt-it-cased", "no_revision_available"),
+    ("Geotrend__distilbert-base-fr-cased", "no_revision_available"),
+    ("KBLab__electra-small-swedish-cased-discriminator", "no_revision_available"),
+    ("KBLab__sentence-bert-swedish-cased", "no_revision_available"),
+    ("KB__bert-base-swedish-cased", "no_revision_available"),
+    ("McGill-NLP__LLM2Vec-Llama-2-7b-chat-hf-mntp-supervised", "no_revision_available"),
+    ("McGill-NLP__LLM2Vec-Llama-2-unsupervised", "no_revision_available"),
+    ("McGill-NLP__LLM2Vec-Meta-Llama-3-supervised", "no_revision_available"),
+    ("McGill-NLP__LLM2Vec-Meta-Llama-3-unsupervised", "no_revision_available"),
+    ("McGill-NLP__LLM2Vec-Mistral-supervised", "no_revision_available"),
+    ("McGill-NLP__LLM2Vec-Mistral-unsupervised", "no_revision_available"),
+    ("McGill-NLP__LLM2Vec-Sheared-Llama-supervised", "no_revision_available"),
+    ("McGill-NLP__LLM2Vec-Sheared-Llama-unsupervised", "no_revision_available"),
+    (
+        "Muennighoff__SGPT-1.3B-weightedmean-msmarco-specb-bitfit",
+        "no_revision_available",
+    ),
+    (
+        "Muennighoff__SGPT-125M-weightedmean-msmarco-specb-bitfit",
+        "no_revision_available",
+    ),
+    (
+        "Muennighoff__SGPT-125M-weightedmean-msmarco-specb-bitfit-doc",
+        "no_revision_available",
+    ),
+    (
+        "Muennighoff__SGPT-125M-weightedmean-msmarco-specb-bitfit-que",
+        "no_revision_available",
+    ),
+    ("Muennighoff__SGPT-125M-weightedmean-nli-bitfit", "no_revision_available"),
+    (
+        "Muennighoff__SGPT-2.7B-weightedmean-msmarco-specb-bitfit",
+        "no_revision_available",
+    ),
+    (
+        "Muennighoff__SGPT-5.8B-weightedmean-msmarco-specb-bitfit",
+        "no_revision_available",
+    ),
+    (
+        "Muennighoff__SGPT-5.8B-weightedmean-msmarco-specb-bitfit-que",
+        "no_revision_available",
+    ),
+    ("Muennighoff__SGPT-5.8B-weightedmean-nli-bitfit", "no_revision_available"),
+    ("NbAiLab__nb-bert-base", "no_revision_available"),
+    ("NbAiLab__nb-bert-large", "no_revision_available"),
+    ("Salesforce__SFR-Embedding-Mistral", "no_revision_available"),
+    (
+        "T-Systems-onsite__cross-en-de-roberta-sentence-transformer",
+        "no_revision_available",
+    ),
+    ("Wissam42__sentence-croissant-llm-base", "no_revision_available"),
+    ("aliyun__OpenSearch-text-hybrid", "no_revision_available"),
+    ("almanach__camembert-base", "no_revision_available"),
+    ("almanach__camembert-large", "no_revision_available"),
+    ("amazon__titan-embed-text-v1", "no_revision_available"),
+    ("baichuan-ai__text-embedding", "no_revision_available"),
+    ("bigscience-data__sgpt-bloom-1b7-nli", "no_revision_available"),
+    ("bigscience-data__sgpt-bloom-7b1-msmarco", "no_revision_available"),
+    ("bm25", "no_revision_available"),
+    ("bm25s", "0_1_10"),
+    ("castorini__monobert-large-msmarco", "no_revision_available"),
+    ("castorini__monot5-3b-msmarco-10k", "no_revision_available"),
+    ("castorini__monot5-base-msmarco-10k", "no_revision_available"),
+    ("chcaa__dfm-encoder-large-v1", "no_revision_available"),
+    ("dangvantuan__sentence-camembert-base", "no_revision_available"),
+    ("dangvantuan__sentence-camembert-large", "no_revision_available"),
+    ("deepfile__embedder-100p", "no_revision_available"),
+    ("deepset__gbert-base", "no_revision_available"),
+    ("deepset__gbert-large", "no_revision_available"),
+    ("deepset__gelectra-base", "no_revision_available"),
+    ("deepset__gelectra-large", "no_revision_available"),
+    ("distilbert__distilbert-base-uncased", "no_revision_available"),
+    ("dwzhu__e5-base-4k", "no_revision_available"),
+    ("elastic__elser-v2", "no_revision_available"),
+    ("facebook__contriever", "2bd46a25019aeea091fd42d1f0fd4801675cf699"),
+    ("facebook__contriever-instruct", "2bd46a25019aeea091fd42d1f0fd4801675cf699"),
+    ("facebook__dpr-ctx_encoder-multiset-base", "no_revision_available"),
+    ("facebook__dragon-plus-context-encoder", "no_revision_available"),
+    ("facebook__tart-full-flan-t5-xl", "no_revision_available"),
+    ("facebookresearch__LASER2", "no_revision_available"),
+    ("facebookresearch__dragon-plus", "no_revision_available"),
+    ("facebookresearch__dragon-plus-instruct", "no_revision_available"),
+    ("intfloat__e5-base", "no_revision_available"),
+    ("intfloat__e5-base-v2", "no_revision_available"),
+    ("intfloat__e5-large", "no_revision_available"),
+    ("intfloat__e5-large-v2", "no_revision_available"),
+    ("intfloat__e5-mistral-7b-instruct", "no_revision_available"),
+    (
+        "intfloat__e5-mistral-7b-instruct-noinstruct",
+        "07163b72af1488142a360786df853f237b1a3ca1",
+    ),
+    ("intfloat__e5-small", "no_revision_available"),
+    ("intfloat__multilingual-e5-base", "no_revision_available"),
+    ("intfloat__multilingual-e5-large", "no_revision_available"),
+    ("intfloat__multilingual-e5-small", "no_revision_available"),
+    ("ipipan__herbert-base-retrieval-v2", "no_revision_available"),
+    ("ipipan__silver-retriever-base-v1", "no_revision_available"),
+    ("izhx__udever-bloom-1b1", "no_revision_available"),
+    ("izhx__udever-bloom-560m", "no_revision_available"),
+    ("jhu-clsp__FollowIR-7B", "no_revision_available"),
+    ("jinaai__jina-embeddings-v2-base-en", "no_revision_available"),
+    ("jonfd__electra-small-nordic", "no_revision_available"),
+    ("ltg__norbert3-base", "no_revision_available"),
+    ("ltg__norbert3-large", "no_revision_available"),
+    ("meta-llama__llama-2-7b-chat", "no_revision_available"),
+    ("mistral__mistral-embed", "no_revision_available"),
+    ("mistralai__mistral-7b-instruct-v0.2", "no_revision_available"),
+    ("moka-ai__m3e-base", "no_revision_available"),
+    ("moka-ai__m3e-large", "no_revision_available"),
+    ("nomic-ai__nomic-embed-text-v1", "no_revision_available"),
+    ("nomic-ai__nomic-embed-text-v1.5-128", "no_revision_available"),
+    ("nomic-ai__nomic-embed-text-v1.5-256", "no_revision_available"),
+    ("nomic-ai__nomic-embed-text-v1.5-512", "no_revision_available"),
+    ("nomic-ai__nomic-embed-text-v1.5-64", "no_revision_available"),
+    ("nthakur__contriever-base-msmarco", "no_revision_available"),
+    ("openai__text-embedding-3-large-256", "no_revision_available"),
+    ("openai__text-embedding-3-large-instruct", "no_revision_available"),
+    ("openai__text-embedding-3-small-instruct", "no_revision_available"),
+    ("openai__text-embedding-ada-002", "no_revision_available"),
+    ("openai__text-embedding-ada-002-instruct", "no_revision_available"),
+    ("openai__text-search-ada-001", "no_revision_available"),
+    ("openai__text-search-ada-doc-001", "no_revision_available"),
+    ("openai__text-search-babbage-001", "no_revision_available"),
+    ("openai__text-search-curie-001", "no_revision_available"),
+    ("openai__text-search-davinci-001", "no_revision_available"),
+    ("openai__text-similarity-ada-001", "no_revision_available"),
+    ("openai__text-similarity-babbage-001", "no_revision_available"),
+    ("openai__text-similarity-curie-001", "no_revision_available"),
+    ("openai__text-similarity-davinci-001", "no_revision_available"),
+    ("orionweller__tart-dual-contriever-msmarco", "no_revision_available"),
+    ("princeton-nlp__sup-simcse-bert-base-uncased", "no_revision_available"),
+    ("princeton-nlp__unsup-simcse-bert-base-uncased", "no_revision_available"),
+    ("sdadas__st-polish-paraphrase-from-distilroberta", "no_revision_available"),
+    ("sdadas__st-polish-paraphrase-from-mpnet", "no_revision_available"),
+    ("sentence-transformers__LaBSE", "no_revision_available"),
+    ("sentence-transformers__all-MiniLM-L6-v2", "no_revision_available"),
+    (
+        "sentence-transformers__all-MiniLM-L6-v2-instruct",
+        "8b3219a92973c328a8e22fadcfa821b5dc75636a",
+    ),
+    (
+        "sentence-transformers__all-mpnet-base-v2-instruct",
+        "84f2bcc00d77236f9e89c8a360a00fb1139bf47d",
+    ),
+    ("sentence-transformers__allenai-specter", "no_revision_available"),
+    (
+        "sentence-transformers__average_word_embeddings_glove.6B.300d",
+        "no_revision_available",
+    ),
+    (
+        "sentence-transformers__average_word_embeddings_komninos",
+        "no_revision_available",
+    ),
+    ("sentence-transformers__distiluse-base-multilingual-cased-v2", ".gitkeep"),
+    (
+        "sentence-transformers__distiluse-base-multilingual-cased-v2",
+        "no_revision_available",
+    ),
+    ("sentence-transformers__gtr-t5-base", "no_revision_available"),
+    ("sentence-transformers__gtr-t5-large", "no_revision_available"),
+    ("sentence-transformers__gtr-t5-xl", "no_revision_available"),
+    ("sentence-transformers__gtr-t5-xxl", "no_revision_available"),
+    ("sentence-transformers__msmarco-bert-co-condensor", "no_revision_available"),
+    ("sentence-transformers__multi-qa-MiniLM-L6-cos-v1", "no_revision_available"),
+    (
+        "sentence-transformers__paraphrase-multilingual-MiniLM-L12-v2",
+        "no_revision_available",
+    ),
+    (
+        "sentence-transformers__paraphrase-multilingual-mpnet-base-v2",
+        "no_revision_available",
+    ),
+    ("sentence-transformers__sentence-t5-base", "no_revision_available"),
+    ("sentence-transformers__sentence-t5-large", "no_revision_available"),
+    ("sentence-transformers__sentence-t5-xl", "no_revision_available"),
+    ("sentence-transformers__sentence-t5-xxl", "no_revision_available"),
+    ("sentence-transformers__use-cmlm-multilingual", "no_revision_available"),
+    ("shibing624__text2vec-base-chinese", "no_revision_available"),
+    ("shibing624__text2vec-base-multilingual", "no_revision_available"),
+    ("shibing624__text2vec-large-chinese", "no_revision_available"),
+    ("silk-road__luotuo-bert-medium", "no_revision_available"),
+    ("uklfr__gottbert-base", "no_revision_available"),
+    ("vesteinn__DanskBERT", "no_revision_available"),
+    ("voyageai__voyage-2", "no_revision_available"),
+    ("voyageai__voyage-code-2", "no_revision_available"),
+    ("voyageai__voyage-large-2-instruct", "no_revision_available"),
+    ("voyageai__voyage-law-2", "no_revision_available"),
+    ("voyageai__voyage-lite-01-instruct", "no_revision_available"),
+    ("voyageai__voyage-lite-02-instruct", "no_revision_available"),
+    ("voyageai__voyage-multilingual-2", "no_revision_available"),
+    ("vprelovac__universal-sentence-encoder-multilingual-3", "no_revision_available"),
+    (
+        "vprelovac__universal-sentence-encoder-multilingual-large-3",
+        "no_revision_available",
+    ),
+]
+
+model_rev_pairs = [
+    (model_folder, rev_folder)
+    for model_folder in results_folder.glob("*")
+    for rev_folder in model_folder.glob("*")
+    if model_folder.name not in [".DS_Store"] and rev_folder.name not in [".DS_Store"]
+]
+pairs_no_meta = [
+    (pair[0].name, pair[1].name)
+    for pair in model_rev_pairs
+    if not (pair[1] / "model_meta.json").exists()
+]
+pairs_no_meta.sort()
+
+
+p = [p for p in model_rev_pairs if "Haon-Chen" in p[0].name][0][1]/ "model_meta.json"
+p.exists()

tests/test_ensure_correct_metadata.py

@@ -0,0 +1,73 @@
+import json
+
+import pytest
+
+from tests.test_correct_folder_structure import folders_without_meta, results_folder
+
+model_rev_pairs = [
+    (model_folder, rev_folder)
+    for model_folder in results_folder.glob("*")
+    for rev_folder in model_folder.glob("*")
+    if model_folder.name not in [".DS_Store"]
+    and rev_folder.name not in [".DS_Store"]
+    and ((model_folder.name, rev_folder.name) not in folders_without_meta)
+]
+
+
+@pytest.mark.parametrize("model_rev_pair", model_rev_pairs)
+def test_model_meta_in_folders(model_rev_pair):
+    """
+    Models added after the 26th of November should contain a model_meta.json file
+    """
+    model_folder, rev_folder = model_rev_pair
+
+    meta_file = rev_folder / "model_meta.json"
+    assert meta_file.exists()
+    assert meta_file.is_file()
+    assert meta_file.parent == rev_folder
+    assert meta_file.suffix == ".json"
+    assert meta_file.stem == "model_meta"
+
+
+# please do not add to this list, this is only for historic results, all new results should include a revision ID
+revision_exceptions = [
+    ("castorini__mdpr-tied-pft-msmarco", "no_revision_available"),
+    ("voyageai__voyage-3", "no_revision_available"),
+    ("sentence-transformers__all-mpnet-base-v2", "no_revision_available"),
+    ("Snowflake__snowflake-arctic-embed-m-v1.5", "no_revision_available"),
+    ("sentence-transformers__all-MiniLM-L12-v2", "no_revision_available"),
+    ("nthakur__mcontriever-base-msmarco", "no_revision_available"),
+    ('voyageai__voyage-3-lite', 'no_revision_available')
+]
+
+
+@pytest.mark.parametrize("model_rev_pair", model_rev_pairs)
+def test_revision_is_specified_for_new_additions(model_rev_pair):
+    """
+    Models added after 26th of November should include a revision ID and can not use the "no_revision_available" fallback.
+    """
+    model_folder, rev_folder = model_rev_pair
+    if (model_folder.name, rev_folder.name) not in revision_exceptions:
+        meta_file = rev_folder / "model_meta.json"
+        with meta_file.open("r") as f:
+            meta = json.load(f)
+        assert meta["revision"].lower() not in [
+            "no_revision_available",
+            "",
+            "na",
+            "no-revision-available",
+        ]
+
+
+@pytest.mark.parametrize("model_rev_pair", model_rev_pairs)
+def test_organization_is_specified_for_new_additions(model_rev_pair):
+    """
+    Models added after 26th of November should include a organization ID within their name, e.g. "myorg/my_embedding_model".
+
+    This is to avoid mispecified names such as "myorg__my_embedding_model" and similar.
+    """
+    model_folder, rev_folder = model_rev_pair
+    meta_file = rev_folder / "model_meta.json"
+    with meta_file.open("r") as f:
+        meta = json.load(f)
+    assert "/" in meta["name"]

tests/test_load_datasets.py

@@ -0,0 +1,12 @@
+from pathlib import Path
+import pytest
+from datasets import load_dataset
+from results import MODELS
+
+
+@pytest.mark.parametrize("model", MODELS)
+@pytest.mark.xfail(reason="If new model added this test will fail")
+def test_load_results_from_datasets(model):
+    """Ensures that all models can be imported from dataset"""
+    path = Path(__file__).parent.parent / "results.py"
+    ds = load_dataset(str(path.absolute()), model, trust_remote_code=True)

tests/test_load_results.py

@@ -0,0 +1,27 @@
+import os
+from pathlib import Path
+
+import mteb
+from mteb.load_results.task_results import TaskResult
+
+
+def test_load_results():
+    """Ensures that files can be loaded using MTEB"""
+    tests_path = Path(__file__).parent / "mock_cache_dir"
+
+    os.environ["MTEB_CACHE"] = str(tests_path)
+
+    results = mteb.load_results(download_latest=False)
+
+    assert isinstance(results, mteb.BenchmarkResults)
+    for model_results in results.model_results:
+        for model_result in model_results:
+            assert isinstance(model_result, TaskResult)
+
+
+def test_load_results_mteb():
+    test_model_name = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
+    model_results = mteb.load_results(models=[test_model_name])
+    model_result = model_results[0]
+    assert model_result.model_name == test_model_name
+    assert model_result.model_revision == "bf3bf13ab40c3157080a7ab344c831b9ad18b5eb"