evalscope 0.5.4__py3-none-any.whl → 0.5.5__py3-none-any.whl

evalscope/backend/__init__.py

@@ -1,3 +0,0 @@
-# Copyright (c) Alibaba, Inc. and its affiliates.
-
-from evalscope.backend.opencompass.backend_manager import OpenCompassBackendManager

evalscope/backend/opencompass/tasks/eval_datasets.py

@@ -7,7 +7,7 @@ with read_base():
     from opencompass.configs.datasets.agieval.agieval_gen_64afd3 import agieval_datasets
     from opencompass.configs.datasets.GaokaoBench.GaokaoBench_gen_5cfe9e import GaokaoBench_datasets
     from opencompass.configs.datasets.humaneval.humaneval_gen_8e312c import humaneval_datasets
-    from opencompass.configs.datasets.mbpp.deprecated_mbpp_gen_1e1056 import mbpp_datasets
+    from opencompass.configs.datasets.mbpp.mbpp_gen_830460 import mbpp_datasets
     from opencompass.configs.datasets.CLUE_C3.CLUE_C3_gen_8c358f import C3_datasets
     from opencompass.configs.datasets.CLUE_CMRC.CLUE_CMRC_gen_1bd3c8 import CMRC_datasets
     from opencompass.configs.datasets.CLUE_DRCD.CLUE_DRCD_gen_1bd3c8 import DRCD_datasets
@@ -45,7 +45,7 @@ with read_base():
     from opencompass.configs.datasets.piqa.piqa_gen_1194eb import piqa_datasets
     from opencompass.configs.datasets.siqa.siqa_gen_e78df3 import siqa_datasets
     from opencompass.configs.datasets.strategyqa.strategyqa_gen_1180a7 import strategyqa_datasets
-    from opencompass.configs.datasets.winogrande.deprecated_winogrande_gen_a9ede5 import winogrande_datasets
+    from opencompass.configs.datasets.winogrande.winogrande_gen_458220 import winogrande_datasets
     from opencompass.configs.datasets.obqa.obqa_gen_9069e4 import obqa_datasets
     from opencompass.configs.datasets.nq.nq_gen_c788f6 import nq_datasets
     from opencompass.configs.datasets.triviaqa.triviaqa_gen_2121ce import triviaqa_datasets

evalscope/backend/rag_eval/__init__.py

@@ -0,0 +1,3 @@
+from evalscope.backend.rag_eval.utils.embedding import EmbeddingModel
+from evalscope.backend.rag_eval.utils.llm import LLM
+from evalscope.backend.rag_eval.backend_manager import RAGEvalBackendManager

evalscope/backend/rag_eval/backend_manager.py

@@ -0,0 +1,68 @@
+import os
+from typing import Optional, Union
+from evalscope.utils import is_module_installed, get_valid_list
+from evalscope.backend.base import BackendManager
+from evalscope.utils.logger import get_logger
+
+
+logger = get_logger()
+
+
+class RAGEvalBackendManager(BackendManager):
+    def __init__(self, config: Union[str, dict], **kwargs):
+        """BackendManager for VLM Evaluation Kit
+
+        Args:
+            config (Union[str, dict]): the configuration yaml-file or the configuration dictionary
+        """
+        super().__init__(config, **kwargs)
+
+    @staticmethod
+    def _check_env(module_name: str):
+        if is_module_installed(module_name):
+            logger.info(f"Check `{module_name}` Installed")
+        else:
+            logger.error(f"Please install `{module_name}` first")
+
+    def run_mteb(self):
+        from evalscope.backend.rag_eval.cmteb import ModelArguments, EvalArguments
+        from evalscope.backend.rag_eval.cmteb import one_stage_eval, two_stage_eval
+
+        if len(self.model_args) > 2:
+            raise ValueError("Not support multiple models yet")
+
+        # Convert arguments to dictionary
+        model_args_list = [ModelArguments(**args).to_dict() for args in self.model_args]
+        eval_args = EvalArguments(**self.eval_args).to_dict()
+
+        if len(model_args_list) == 1:
+            one_stage_eval(model_args_list[0], eval_args)
+        else:  # len(model_args_list) == 2
+            two_stage_eval(model_args_list[0], model_args_list[1], eval_args)
+
+    def run_ragas(self):
+        from evalscope.backend.rag_eval.ragas import rag_eval, testset_generation
+        from evalscope.backend.rag_eval.ragas import (
+            TestsetGenerationArguments,
+            EvaluationArguments,
+        )
+
+        if self.testset_args is not None:
+            testset_generation(TestsetGenerationArguments(**self.testset_args))
+        if self.eval_args is not None:
+            rag_eval(EvaluationArguments(**self.eval_args))
+
+    def run(self, *args, **kwargs):
+        tool = self.config_d.pop("tool")
+        if tool.lower() == "mteb":
+            self._check_env("mteb")
+            self.model_args = self.config_d["model"]
+            self.eval_args = self.config_d["eval"]
+            self.run_mteb()
+        elif tool.lower() == "ragas":
+            self._check_env("ragas")
+            self.testset_args = self.config_d.get("testset_generation", None)
+            self.eval_args = self.config_d.get("eval", None)
+            self.run_ragas()
+        else:
+            raise ValueError(f"Unknown tool: {tool}")

evalscope/backend/rag_eval/cmteb/__init__.py

@@ -0,0 +1,4 @@
+from evalscope.backend.rag_eval.cmteb.tasks import *
+from evalscope.backend.rag_eval.cmteb.base import *
+from evalscope.backend.rag_eval.cmteb.arguments import ModelArguments, EvalArguments
+from evalscope.backend.rag_eval.cmteb.task_template import one_stage_eval, two_stage_eval

evalscope/backend/rag_eval/cmteb/arguments.py

@@ -0,0 +1,59 @@
+from dataclasses import dataclass, field
+from typing import List, Optional, Union, Dict, Any
+
+
+@dataclass
+class ModelArguments:
+    # Arguments for embeding model: sentence transformer or cross encoder
+    model_name_or_path: str = ""  # model name or path
+    is_cross_encoder: bool = False  # whether the model is a cross encoder
+    # pooling mode: Either “cls”, “lasttoken”, “max”, “mean”, “mean_sqrt_len_tokens”, or “weightedmean”.
+    pooling_mode: Optional[str] = None
+    max_seq_length: int = 512  # max sequence length
+    # prompt for llm based model
+    prompt: str = ""
+    # model kwargs
+    model_kwargs: dict = field(default_factory=lambda: {"torch_dtype": "auto"})
+    # config kwargs
+    config_kwargs: Dict[str, Any] = field(default_factory=dict)
+    # encode kwargs
+    encode_kwargs: dict = field(
+        default_factory=lambda: {"show_progress_bar": True, "batch_size": 32}
+    )
+    hub: str = "modelscope"  # modelscope or huggingface
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "model_name_or_path": self.model_name_or_path,
+            "is_cross_encoder": self.is_cross_encoder,
+            "pooling_mode": self.pooling_mode,
+            "max_seq_length": self.max_seq_length,
+            "prompt": self.prompt,
+            "model_kwargs": self.model_kwargs,
+            "config_kwargs": self.config_kwargs,
+            "encode_kwargs": self.encode_kwargs,
+            "hub": self.hub,
+        }
+
+
+@dataclass
+class EvalArguments:
+    # Evaluation
+    tasks: List[str] = field(default_factory=list)  # task names
+    verbosity: int = 2  # verbosity level 0-3
+    output_folder: str = "outputs"  # output folder
+    overwrite_results: bool = True  # overwrite results
+    limits: Optional[int] = None  # limit number of samples
+    hub: str = "modelscope"  # modelscope or huggingface
+    top_k: int = 5
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "tasks": self.tasks,
+            "verbosity": self.verbosity,
+            "output_folder": self.output_folder,
+            "overwrite_results": self.overwrite_results,
+            "limits": self.limits,
+            "hub": self.hub,
+            "top_k": 5,
+        }

evalscope/backend/rag_eval/cmteb/base.py

@@ -0,0 +1,89 @@
+from collections import defaultdict
+from typing import List
+from mteb import AbsTask
+from datasets import DatasetDict
+from modelscope import MsDataset
+import datasets
+from evalscope.backend.rag_eval.cmteb.tasks import CLS_DICT, CLS_RETRIEVAL
+
+__all__ = ["TaskBase"]
+
+
+
+class TaskBase:
+
+    @staticmethod
+    def get_tasks(task_names, **kwargs) -> List[AbsTask]:
+
+        return [TaskBase.get_task(task_name, **kwargs) for task_name in task_names]
+
+    @staticmethod
+    def get_task(task_name, **kwargs) -> AbsTask:
+
+        if task_name not in CLS_DICT:
+            from mteb.overview import TASKS_REGISTRY
+
+            task_cls = TASKS_REGISTRY[task_name]
+            if task_cls.metadata.type != "Retrieval":
+                task_cls.load_data = load_data
+        else:
+            task_cls = CLS_DICT[task_name]
+            task_cls.load_data = load_data
+        # init task instance
+        task_instance = task_cls()
+        return task_instance
+
+
+def load_data(self, **kwargs):
+    """Load dataset from the hub, compatible with ModelScope and Hugging Face."""
+    if self.data_loaded:
+        return
+
+    limits = kwargs.get("limits", None)
+    hub = kwargs.get("hub", "modelscope")
+    name = self.metadata_dict.get("name")
+    path = self.metadata_dict["dataset"].get("path")
+
+    assert path is not None, "Path must be specified in dataset"
+
+    # Loading the dataset based on the source hub
+    if hub == "modelscope":
+        import re
+
+        path = re.sub(r"^mteb/", "MTEB/", path)
+        dataset = MsDataset.load(path)
+    else:
+        dataset = datasets.load_dataset(**self.metadata_dict["dataset"])  # type: ignore
+
+    if limits is not None:
+        dataset = {
+            split: dataset[split].select(range(min(limits, len(dataset[split]))))
+            for split in dataset.keys()
+        }
+
+    if name in CLS_RETRIEVAL:
+        self.corpus, self.queries, self.relevant_docs = load_retrieval_data(
+            dataset,
+            path,
+            self.metadata_dict["eval_splits"],
+        )
+
+    self.dataset = dataset
+    self.dataset_transform()
+    self.data_loaded = True
+
+
+def load_retrieval_data(dataset, dataset_name: str, eval_splits: list) -> tuple:
+    eval_split = eval_splits[0]
+    qrels = MsDataset.load(dataset_name + "-qrels")[eval_split]
+
+    corpus = {e["id"]: {"text": e["text"]} for e in dataset["corpus"]}
+    queries = {e["id"]: e["text"] for e in dataset["queries"]}
+    relevant_docs = defaultdict(dict)
+    for e in qrels:
+        relevant_docs[e["qid"]][e["pid"]] = e["score"]
+
+    corpus = DatasetDict({eval_split: corpus})
+    queries = DatasetDict({eval_split: queries})
+    relevant_docs = DatasetDict({eval_split: relevant_docs})
+    return corpus, queries, relevant_docs

evalscope/backend/rag_eval/cmteb/task_template.py

@@ -0,0 +1,83 @@
+import os
+import mteb
+from evalscope.backend.rag_eval import EmbeddingModel
+from evalscope.backend.rag_eval import cmteb
+from mteb.task_selection import results_to_dataframe
+from evalscope.utils.logger import get_logger
+
+logger = get_logger()
+
+
+def show_results(output_folder, model, results):
+    model_name = model.mteb_model_meta.model_name_as_path()
+    revision = model.mteb_model_meta.revision
+
+    results_df = results_to_dataframe({model_name: {revision: results}})
+
+    save_path = os.path.join(
+        output_folder,
+        model_name,
+        revision,
+    )
+    logger.info(f"Evaluation results:\n{results_df.to_markdown()}")
+    logger.info(f"Evaluation results saved in {os.path.abspath(save_path)}")
+
+
+def one_stage_eval(
+    model_args,
+    eval_args,
+) -> None:
+    # load model
+    model = EmbeddingModel.load(**model_args)
+
+    # load task first to update instructions
+    tasks = cmteb.TaskBase.get_tasks(task_names=eval_args["tasks"])
+    evaluation = mteb.MTEB(tasks=tasks)
+
+    # run evaluation
+    results = evaluation.run(model, **eval_args)
+
+    # save and log results
+    show_results(eval_args["output_folder"], model, results)
+
+
+def two_stage_eval(
+    model1_args,
+    model2_args,
+    eval_args,
+) -> None:
+    """a two-stage run with the second stage reading results saved from the first stage."""
+    # load model
+    dual_encoder = EmbeddingModel.load(**model1_args)
+    cross_encoder = EmbeddingModel.load(**model2_args)
+
+    first_stage_path = f"{eval_args['output_folder']}/stage1"
+    second_stage_path = f"{eval_args['output_folder']}/stage2"
+
+    tasks = cmteb.TaskBase.get_tasks(task_names=eval_args["tasks"])
+    for task in tasks:
+        evaluation = mteb.MTEB(tasks=[task])
+
+        # stage 1: run dual encoder
+        evaluation.run(
+            dual_encoder,
+            save_predictions=True,
+            output_folder=first_stage_path,
+            overwrite_results=True,
+            hub=eval_args["hub"],
+            limits=eval_args["limits"],
+        )
+        # stage 2: run cross encoder
+        results = evaluation.run(
+            cross_encoder,
+            top_k=eval_args["top_k"],
+            save_predictions=True,
+            output_folder=second_stage_path,
+            previous_results=f"{first_stage_path}/{task.metadata.name}_default_predictions.json",
+            overwrite_results=True,
+            hub=eval_args["hub"],
+            limits=eval_args["limits"],
+        )
+
+        # save and log results
+        show_results(second_stage_path, cross_encoder, results)

evalscope/backend/rag_eval/cmteb/tasks/Classification.py

@@ -0,0 +1,302 @@
+from mteb.abstasks.AbsTaskClassification import AbsTaskClassification
+from mteb.abstasks.TaskMetadata import TaskMetadata
+
+
+class TNews(AbsTaskClassification):
+    metadata = TaskMetadata(
+        name="TNews",
+        description="Short Text Classification for News",
+        reference="https://www.cluebenchmarks.com/introduce.html",
+        dataset={
+            "path": "C-MTEB/TNews-classification",
+            "revision": "317f262bf1e6126357bbe89e875451e4b0938fe4",
+        },
+        type="Classification",
+        category="s2s",
+        modalities=["text"],
+        eval_splits=["validation"],
+        eval_langs=["cmn-Hans"],
+        main_score="accuracy",
+        date=None,
+        domains=None,
+        task_subtypes=None,
+        license=None,
+        annotations_creators=None,
+        dialect=None,
+        sample_creation=None,
+        bibtex_citation="""@inproceedings {xu-etal-2020-clue,
+ title = "{CLUE}: A {C}hinese Language Understanding Evaluation Benchmark",
+ author = "Xu, Liang  and
+    Hu, Hai and
+    Zhang, Xuanwei and
+    Li, Lu and
+    Cao, Chenjie and
+    Li, Yudong and
+    Xu, Yechen and
+    Sun, Kai and
+    Yu, Dian and
+    Yu, Cong and
+    Tian, Yin and
+    Dong, Qianqian and
+    Liu, Weitang and
+    Shi, Bo and
+    Cui, Yiming and
+    Li, Junyi and
+    Zeng, Jun and
+    Wang, Rongzhao and
+    Xie, Weijian and
+    Li, Yanting and
+    Patterson, Yina and
+    Tian, Zuoyu and
+    Zhang, Yiwen and
+    Zhou, He and
+    Liu, Shaoweihua and
+    Zhao, Zhe and
+    Zhao, Qipeng and
+    Yue, Cong and
+    Zhang, Xinrui and
+    Yang, Zhengliang and
+    Richardson, Kyle and
+    Lan, Zhenzhong ",
+ booktitle = "Proceedings of the 28th International Conference on Computational Linguistics",
+ month = dec,
+ year = "2020",
+ address = "Barcelona, Spain (Online)",
+ publisher = "International Committee on Computational Linguistics",
+ url = "https://aclanthology.org/2020.coling-main.419",
+ doi = "10.18653/v1/2020.coling-main.419",
+ pages = "4762--4772",
+}""",
+        descriptive_stats={"n_samples": None, "avg_character_length": None},
+    )
+
+    @property
+    def metadata_dict(self) -> dict[str, str]:
+        metadata_dict = super().metadata_dict
+        metadata_dict["samples_per_label"] = 32
+        return metadata_dict
+
+
+class IFlyTek(AbsTaskClassification):
+    metadata = TaskMetadata(
+        name="IFlyTek",
+        description="Long Text classification for the description of Apps",
+        reference="https://www.cluebenchmarks.com/introduce.html",
+        dataset={
+            "path": "C-MTEB/IFlyTek-classification",
+            "revision": "421605374b29664c5fc098418fe20ada9bd55f8a",
+        },
+        type="Classification",
+        category="s2s",
+        modalities=["text"],
+        eval_splits=["validation"],
+        eval_langs=["cmn-Hans"],
+        main_score="accuracy",
+        date=None,
+        domains=None,
+        task_subtypes=None,
+        license=None,
+        annotations_creators=None,
+        dialect=None,
+        sample_creation=None,
+        bibtex_citation="""@inproceedings {xu-etal-2020-clue,
+ title = "{CLUE}: A {C}hinese Language Understanding Evaluation Benchmark",
+ author = "Xu, Liang  and
+    Hu, Hai and
+    Zhang, Xuanwei and
+    Li, Lu and
+    Cao, Chenjie and
+    Li, Yudong and
+    Xu, Yechen and
+    Sun, Kai and
+    Yu, Dian and
+    Yu, Cong and
+    Tian, Yin and
+    Dong, Qianqian and
+    Liu, Weitang and
+    Shi, Bo and
+    Cui, Yiming and
+    Li, Junyi and
+    Zeng, Jun and
+    Wang, Rongzhao and
+    Xie, Weijian and
+    Li, Yanting and
+    Patterson, Yina and
+    Tian, Zuoyu and
+    Zhang, Yiwen and
+    Zhou, He and
+    Liu, Shaoweihua and
+    Zhao, Zhe and
+    Zhao, Qipeng and
+    Yue, Cong and
+    Zhang, Xinrui and
+    Yang, Zhengliang and
+    Richardson, Kyle and
+    Lan, Zhenzhong ",
+ booktitle = "Proceedings of the 28th International Conference on Computational Linguistics",
+ month = dec,
+ year = "2020",
+ address = "Barcelona, Spain (Online)",
+ publisher = "International Committee on Computational Linguistics",
+ url = "https://aclanthology.org/2020.coling-main.419",
+ doi = "10.18653/v1/2020.coling-main.419",
+ pages = "4762--4772",
+ abstract = "The advent of natural language understanding (NLU) benchmarks for English, such as GLUE and SuperGLUE allows new NLU models to be evaluated across a diverse set of tasks. These comprehensive benchmarks have facilitated a broad range of research and applications in natural language processing (NLP). The problem, however, is that most such benchmarks are limited to English, which has made it difficult to replicate many of the successes in English NLU for other languages. To help remedy this issue, we introduce the first large-scale Chinese Language Understanding Evaluation (CLUE) benchmark. CLUE is an open-ended, community-driven project that brings together 9 tasks spanning several well-established single-sentence/sentence-pair classification tasks, as well as machine reading comprehension, all on original Chinese text. To establish results on these tasks, we report scores using an exhaustive set of current state-of-the-art pre-trained Chinese models (9 in total). We also introduce a number of supplementary datasets and additional tools to help facilitate further progress on Chinese NLU. Our benchmark is released at https://www.cluebenchmarks.com",
+}""",
+        descriptive_stats={"n_samples": None, "avg_character_length": None},
+    )
+
+    @property
+    def metadata_dict(self) -> dict[str, str]:
+        metadata_dict = super().metadata_dict
+        metadata_dict["samples_per_label"] = 32
+        metadata_dict["n_experiments"] = 5
+        return metadata_dict
+
+
+class MultilingualSentiment(AbsTaskClassification):
+    metadata = TaskMetadata(
+        name="MultilingualSentiment",
+        description="A collection of multilingual sentiments datasets grouped into 3 classes -- positive, neutral, negative",
+        reference="https://github.com/tyqiangz/multilingual-sentiment-datasets",
+        dataset={
+            "path": "C-MTEB/MultilingualSentiment-classification",
+            "revision": "46958b007a63fdbf239b7672c25d0bea67b5ea1a",
+        },
+        type="Classification",
+        category="s2s",
+        modalities=["text"],
+        eval_splits=["validation", "test"],
+        eval_langs=["cmn-Hans"],
+        main_score="accuracy",
+        date=None,
+        domains=None,
+        task_subtypes=None,
+        license=None,
+        annotations_creators=None,
+        dialect=None,
+        sample_creation=None,
+        bibtex_citation=None,
+        descriptive_stats={"n_samples": None, "avg_character_length": None},
+    )
+
+    @property
+    def metadata_dict(self) -> dict[str, str]:
+        metadata_dict = super().metadata_dict
+        metadata_dict["samples_per_label"] = 32
+        return metadata_dict
+
+
+class JDReview(AbsTaskClassification):
+    metadata = TaskMetadata(
+        name="JDReview",
+        description="review for iphone",
+        reference="https://aclanthology.org/2023.nodalida-1.20/",
+        dataset={
+            "path": "C-MTEB/JDReview-classification",
+            "revision": "b7c64bd89eb87f8ded463478346f76731f07bf8b",
+        },
+        type="Classification",
+        category="s2s",
+        modalities=["text"],
+        eval_splits=["test"],
+        eval_langs=["cmn-Hans"],
+        main_score="accuracy",
+        date=None,
+        domains=None,
+        task_subtypes=None,
+        license=None,
+        annotations_creators=None,
+        dialect=None,
+        sample_creation=None,
+        bibtex_citation="""@article{xiao2023c,
+  title={C-pack: Packaged resources to advance general chinese embedding},
+  author={Xiao, Shitao and Liu, Zheng and Zhang, Peitian and Muennighof, Niklas},
+  journal={arXiv preprint arXiv:2309.07597},
+  year={2023}
+}""",
+        descriptive_stats={"n_samples": None, "avg_character_length": None},
+    )
+
+    @property
+    def metadata_dict(self) -> dict[str, str]:
+        metadata_dict = super().metadata_dict
+        metadata_dict["samples_per_label"] = 32
+        return metadata_dict
+
+
+class OnlineShopping(AbsTaskClassification):
+    metadata = TaskMetadata(
+        name="OnlineShopping",
+        description="Sentiment Analysis of User Reviews on Online Shopping Websites",
+        reference="https://aclanthology.org/2023.nodalida-1.20/",
+        dataset={
+            "path": "C-MTEB/OnlineShopping-classification",
+            "revision": "e610f2ebd179a8fda30ae534c3878750a96db120",
+        },
+        type="Classification",
+        category="s2s",
+        modalities=["text"],
+        eval_splits=["test"],
+        eval_langs=["cmn-Hans"],
+        main_score="accuracy",
+        date=None,
+        domains=None,
+        task_subtypes=None,
+        license=None,
+        annotations_creators=None,
+        dialect=None,
+        sample_creation=None,
+        bibtex_citation="""@article{xiao2023c,
+  title={C-pack: Packaged resources to advance general chinese embedding},
+  author={Xiao, Shitao and Liu, Zheng and Zhang, Peitian and Muennighof, Niklas},
+  journal={arXiv preprint arXiv:2309.07597},
+  year={2023}
+}""",
+        descriptive_stats={"n_samples": None, "avg_character_length": None},
+    )
+
+    @property
+    def metadata_dict(self) -> dict[str, str]:
+        metadata_dict = super().metadata_dict
+        metadata_dict["samples_per_label"] = 32
+        return metadata_dict
+
+
+class Waimai(AbsTaskClassification):
+    metadata = TaskMetadata(
+        name="Waimai",
+        description="Sentiment Analysis of user reviews on takeaway platforms",
+        reference="https://aclanthology.org/2023.nodalida-1.20/",
+        dataset={
+            "path": "C-MTEB/waimai-classification",
+            "revision": "339287def212450dcaa9df8c22bf93e9980c7023",
+        },
+        type="Classification",
+        category="s2s",
+        modalities=["text"],
+        eval_splits=["test"],
+        eval_langs=["cmn-Hans"],
+        main_score="accuracy",
+        date=None,
+        domains=None,
+        task_subtypes=None,
+        license=None,
+        annotations_creators=None,
+        dialect=None,
+        sample_creation=None,
+        bibtex_citation="""@article{xiao2023c,
+  title={C-pack: Packaged resources to advance general chinese embedding},
+  author={Xiao, Shitao and Liu, Zheng and Zhang, Peitian and Muennighof, Niklas},
+  journal={arXiv preprint arXiv:2309.07597},
+  year={2023}
+}""",
+        descriptive_stats={"n_samples": None, "avg_character_length": None},
+    )
+
+    @property
+    def metadata_dict(self) -> dict[str, str]:
+        metadata_dict = super().metadata_dict
+        metadata_dict["samples_per_label"] = 32
+
+        return metadata_dict