PT subsets of MAPA and MULTIEURLEX

portuguese_benchmark.py

@@ -232,7 +232,7 @@ _ULYSSESNER_META_KWARGS = dict(
     url="https://github.com/ulysses-camara/ulysses-ner-br",
 )
 _ULYSSESNER_PL_KWARGS = dict(
-    name = "UlyssesNER-Br-PL",
+    name = "UlyssesNER-Br-PL-coarse",
     data_urls = {
         "train": "https://github.com/ulysses-camara/ulysses-ner-br/raw/main/annotated-corpora/PL_corpus_conll/pl_corpus_categorias/train.txt",
         "validation":  "https://github.com/ulysses-camara/ulysses-ner-br/raw/main/annotated-corpora/PL_corpus_conll/pl_corpus_categorias/valid.txt",
@@ -242,7 +242,7 @@ _ULYSSESNER_PL_KWARGS = dict(
     **_ULYSSESNER_META_KWARGS
 )
 _ULYSSESNER_C_KWARGS = dict(
-    name = "UlyssesNER-Br-C",
+    name = "UlyssesNER-Br-C-coarse",
     data_urls = {
         "train": "https://github.com/ulysses-camara/ulysses-ner-br/raw/main/annotated-corpora/C_corpus_conll/c_corpus_categorias/train.txt",
         "validation":  "https://github.com/ulysses-camara/ulysses-ner-br/raw/main/annotated-corpora/C_corpus_conll/c_corpus_categorias/valid.txt",
@@ -253,7 +253,7 @@ _ULYSSESNER_C_KWARGS = dict(
 )
 
 _ULYSSESNER_PL_TIPOS_KWARGS = dict(
-    name = "UlyssesNER-Br-PL-tipos",
+    name = "UlyssesNER-Br-PL-fine",
     data_urls = {
         "train": "https://github.com/ulysses-camara/ulysses-ner-br/raw/main/annotated-corpora/PL_corpus_conll/pl_corpus_tipos/train.txt",
         "validation":  "https://github.com/ulysses-camara/ulysses-ner-br/raw/main/annotated-corpora/PL_corpus_conll/pl_corpus_tipos/valid.txt",
@@ -265,7 +265,7 @@ _ULYSSESNER_PL_TIPOS_KWARGS = dict(
     **_ULYSSESNER_META_KWARGS
 )
 _ULYSSESNER_C_TIPOS_KWARGS = dict(
-    name = "UlyssesNER-Br-C-tipos",
+    name = "UlyssesNER-Br-C-fine",
     data_urls = {
         "train": "https://github.com/ulysses-camara/ulysses-ner-br/raw/main/annotated-corpora/C_corpus_conll/c_corpus_tipos/train.txt",
         "validation":  "https://github.com/ulysses-camara/ulysses-ner-br/raw/main/annotated-corpora/C_corpus_conll/c_corpus_tipos/valid.txt",
@@ -347,17 +347,102 @@ HAREM_BASE_KWARGS = dict(
 )
 HAREM_DEFAULT_KWARGS = dict(
     name = "harem-default",
-    hf_config_name = "default",
+    extra_configs = {"name": "default"},
     label_classes = ["PESSOA", "ORGANIZACAO", "LOCAL", "TEMPO", "VALOR", "ABSTRACCAO", "ACONTECIMENTO", "COISA", "OBRA", "OUTRO"],
     **HAREM_BASE_KWARGS
 )
 HAREM_SELECTIVE_KWARGS = dict(
     name = "harem-selective",
-    hf_config_name = "selective",
+    extra_configs = {"name": "selective"},
     label_classes = ["PESSOA", "ORGANIZACAO", "LOCAL", "TEMPO", "VALOR"],
     **HAREM_BASE_KWARGS
 )
 
+_MAPA_BASE_KWARGS = dict(
+    task_type = "ner",
+    data_urls = "joelito/mapa",
+    file_type="hf_dataset",
+    url = "",
+    description =textwrap.dedent(
+            """\
+        The dataset consists of 12 documents (9 for Spanish due to parsing errors) taken from EUR-Lex, 
+        a multilingual corpus of court decisions and legal dispositions in the 24 official languages 
+        of the European Union. The documents have been annotated for named entities following the 
+        guidelines of the MAPA project which foresees two annotation level, a general and a more 
+        fine-grained one. The annotated corpus can be used for named entity recognition/classification."""
+    ),
+    citation = textwrap.dedent(
+        """\
+        @article{DeGibertBonet2022,
+            author = {{de Gibert Bonet}, Ona and {Garc{\'{i}}a Pablos}, Aitor and Cuadros, Montse and Melero, Maite},
+            journal = {Proceedings of the Language Resources and Evaluation Conference},
+            number = {June},
+            pages = {3751--3760},
+            title = {{Spanish Datasets for Sensitive Entity Detection in the Legal Domain}},
+            url = {https://aclanthology.org/2022.lrec-1.400},
+            year = {2022}
+        }"""
+    )
+)
+_MAPA_BASE_KWARGS['filter'] = lambda item: item["language"] == "pt"
+_MAPA_COARSE_KWARGS = dict(
+    name = "mapa_pt_coarse",
+    text_and_label_columns = ["tokens", "coarse_grained"],
+    label_classes = ['ADDRESS', 'AMOUNT', 'DATE', 'ORGANISATION', 'PERSON', 'TIME'],
+    **_MAPA_BASE_KWARGS
+)
+
+_MAPA_FINE_KWARGS = dict(
+    name = "mapa_pt_fine",
+    text_and_label_columns = ["tokens", "fine_grained"],
+    label_classes = ['AGE', 'BUILDING', 'CITY', 'COUNTRY', 'DAY', 'ETHNIC CATEGORY', 
+                     'FAMILY NAME', 'INITIAL NAME', 'MARITAL STATUS', 'MONTH', 'NATIONALITY', 
+                     'PLACE', 'PROFESSION', 'ROLE', 'STANDARD ABBREVIATION', 'TERRITORY', 
+                     'TITLE', 'TYPE', 'UNIT', 'URL', 'VALUE', 'YEAR'],
+    **_MAPA_BASE_KWARGS
+)
+    
+
+_MULTIEURLEX_BASE_KWARGS = dict(
+    name = "multi_eurlex_pt",
+    task_type = "multilabel_classification",
+    data_urls = "multi_eurlex",
+    file_type="hf_dataset",
+    extra_configs = {"language": "pt", "label_level": "level_1"},
+    text_and_label_columns = ["text", "labels"],
+    url = "https://github.com/nlpaueb/MultiEURLEX/",
+    description =textwrap.dedent(
+            """\
+         MultiEURLEX comprises 65k EU laws in 23 official EU languages. 
+         Each EU law has been annotated with EUROVOC concepts (labels) by the Publication Office of EU. 
+         Each EUROVOC label ID is associated with a label descriptor, e.g., [60, agri-foodstuffs], 
+         [6006, plant product], [1115, fruit]. The descriptors are also available in the 23 languages. 
+         Chalkidis et al. (2019) published a monolingual (English) version of this dataset, called EUR-LEX, 
+         comprising 57k EU laws with the originally assigned gold labels."""
+    ),
+    citation = textwrap.dedent(
+        """\
+        @InProceedings{chalkidis-etal-2021-multieurlex,
+          author = {Chalkidis, Ilias  
+                        and Fergadiotis, Manos
+                        and Androutsopoulos, Ion},
+          title = {MultiEURLEX -- A multi-lingual and multi-label legal document 
+                       classification dataset for zero-shot cross-lingual transfer},
+          booktitle = {Proceedings of the 2021 Conference on Empirical Methods
+                       in Natural Language Processing},
+          year = {2021},
+          publisher = {Association for Computational Linguistics},
+          location = {Punta Cana, Dominican Republic},
+          url = {https://arxiv.org/abs/2109.00904}
+        }"""
+    ),
+    label_classes = [
+        "100149","100160","100148","100147","100152","100143","100156",
+        "100158","100154","100153","100142","100145","100150","100162",
+        "100159","100144","100151","100157","100161","100146","100155"
+    ]
+)
+
 class PTBenchmarkConfig(datasets.BuilderConfig):
     """BuilderConfig for PTBenchmark."""
 
@@ -371,8 +456,9 @@ class PTBenchmarkConfig(datasets.BuilderConfig):
         file_type: Optional[str] = None, #filetype (csv, tsc, jsonl)
         text_and_label_columns: Optional[List[str]] = None, #columns for train, dev and test for csv datasets
         indexes_url: Optional[str] = None, #indexes for train, dev and test for single file datasets
-        process_label: Optional[Callable[[str], str]] = lambda x: x,
-        hf_config_name = "default",
+        process_label: Callable[[str], str] = lambda x: x,
+        filter: Callable = lambda x: True,
+        extra_configs: Dict = {},
         **kwargs,
     ):
         """BuilderConfig for GLUE.
@@ -403,7 +489,8 @@ class PTBenchmarkConfig(datasets.BuilderConfig):
         self.text_and_label_columns = text_and_label_columns
         self.indexes_url = indexes_url
         self.process_label = process_label
-        self.hf_config_name = hf_config_name
+        self.filter = filter
+        self.extra_configs = extra_configs
 
 def _get_classification_features(config: PTBenchmarkConfig):
     return datasets.Features(
@@ -414,6 +501,17 @@ def _get_classification_features(config: PTBenchmarkConfig):
         }
     )
 
+def _get_multilabel_classification_features(config: PTBenchmarkConfig):
+    return datasets.Features(
+        {
+            "idx": datasets.Value("int32"),
+            "sentence": datasets.Value("string"),
+            "labels": datasets.Sequence(
+                datasets.features.ClassLabel(names=config.label_classes)
+            ),
+        }
+    )
+
 def _get_ner_features(config: PTBenchmarkConfig):
     bio_labels = ["O"]
     for label_name in config.label_classes:
@@ -534,6 +632,56 @@ def _assin2_generator(file_path, config: PTBenchmarkConfig):
             yield id_, example
             id_ += 1
 
+def _hf_dataset_generator(split, config: PTBenchmarkConfig):
+    dataset = datasets.load_dataset(config.data_urls, split=split, **config.extra_configs)
+    feature_col, label_col = config.text_and_label_columns
+    
+    target_feature_col, target_label_col = feature_col, label_col
+    if config.task_type == "classification":
+        target_feature_col, target_label_col = "sentence", "label"
+    elif config.task_type == "multilabel_classification":
+        target_feature_col, target_label_col = "sentence", "labels"
+    elif config.task_type == "ner":
+        target_feature_col, target_label_col = "tokens", "ner_tags"
+
+    for id, item in enumerate(dataset):
+        #filter invalid items
+        if not config.filter(item):
+            continue
+
+        label = item[label_col]
+        #Convert label to original text
+        if isinstance(dataset.features[label_col], ClassLabel):
+            if isinstance(label, list):
+                label = [dataset.features[label_col].int2str(l) for l in label]
+            else:
+                label = dataset.features[label_col].int2str(label)
+        
+        #Process label
+        if isinstance(label, list):
+            label = [config.process_label(l) for l in label]
+        else:
+            label = config.process_label(label)
+
+        #Filter out invalid classes
+        if config.task_type != "ner":
+            if isinstance(label, list):
+                invalid = False
+                for i in range(len(label)):
+                    if label[i] not in config.label_classes:
+                        invalid = True
+                        break
+                if invalid:
+                    continue
+            else:
+                if label not in config.label_classes:
+                    continue
+
+        yield id, {
+            "idx": id,
+            target_feature_col: item[feature_col],
+            target_label_col: label,
+        }
 
 class PTBenchmark(datasets.GeneratorBasedBuilder):
     BUILDER_CONFIGS = [
@@ -541,16 +689,19 @@ class PTBenchmark(datasets.GeneratorBasedBuilder):
             **CONFIG_KWARGS
         ) \
         for CONFIG_KWARGS in \
-            [_LENERBR_KWARGS, _ASSIN2_RTE_KWARGS, _ASSIN2_STS_KWARGS, _HATEBR_KWARGS, \
-             _ULYSSESNER_PL_KWARGS, _ULYSSESNER_C_KWARGS, _ULYSSESNER_PL_TIPOS_KWARGS, \
-            _ULYSSESNER_C_TIPOS_KWARGS, _BRAZILIAN_COURT_DECISIONS_JUDGMENT, _BRAZILIAN_COURT_DECISIONS_UNANIMITY, \
-            HAREM_DEFAULT_KWARGS, HAREM_SELECTIVE_KWARGS]
+            [_LENERBR_KWARGS, _ASSIN2_RTE_KWARGS, _ASSIN2_STS_KWARGS, _HATEBR_KWARGS,
+            _ULYSSESNER_PL_KWARGS, _ULYSSESNER_C_KWARGS, _ULYSSESNER_PL_TIPOS_KWARGS,
+            _ULYSSESNER_C_TIPOS_KWARGS, _BRAZILIAN_COURT_DECISIONS_JUDGMENT, 
+            _BRAZILIAN_COURT_DECISIONS_UNANIMITY, HAREM_DEFAULT_KWARGS, HAREM_SELECTIVE_KWARGS, 
+            _MULTIEURLEX_BASE_KWARGS, _MAPA_COARSE_KWARGS, _MAPA_FINE_KWARGS]
     ]
 
     def _info(self) -> datasets.DatasetInfo:
         features = None
         if self.config.task_type == "classification":
             features = _get_classification_features(self.config)
+        elif self.config.task_type == "multilabel_classification":
+            features = _get_multilabel_classification_features(self.config)
         elif self.config.task_type == "ner":
             features = _get_ner_features(self.config)
         elif self.config.task_type == "rte":
@@ -619,8 +770,8 @@ class PTBenchmark(datasets.GeneratorBasedBuilder):
     ):
         logger.info("⏳ Generating examples from = %s", file_path)
         if self.config.file_type == "hf_dataset":
-            dataset = datasets.load_dataset(self.config.data_urls, self.config.hf_config_name, split=split)
-            text_col, label_col = self.config.text_and_label_columns
+            yield from _hf_dataset_generator(split, self.config)
+            return
 
         if self.config.task_type == "classification":
             if self.config.file_type == "csv":
@@ -630,32 +781,10 @@ class PTBenchmark(datasets.GeneratorBasedBuilder):
                     indexes_path=indexes_path,
                     split=split
                 )
-            elif self.config.file_type == "hf_dataset":
-                for id, item in enumerate(dataset):
-                    label = item[label_col]
-                    if label not in self.config.label_classes:
-                        continue  # filter out invalid classes to construct ClassLabel
-                    if isinstance(dataset.features[label_col], ClassLabel):
-                        label = dataset.features[label_col].int2str(label)
-                    yield id, {
-                        "idx": id,
-                        "sentence": item[text_col],
-                        "label": self.config.process_label(label),
-                    }
+        elif self.config.task_type == "multilabel_classification":
+            pass
         elif self.config.task_type == "ner":
-            if self.config.file_type == "hf_dataset":
-                for id, item in enumerate(dataset):
-                    tags = item[label_col]
-                    if isinstance(dataset.features[label_col], ClassLabel):
-                        for i in range(len(tags)):
-                            tags[i] = self.config.process_label(dataset.features[label_col].int2str(tags[i]))
-                    yield id, {
-                        "idx": id,
-                        "tokens": item[text_col],
-                        "ner_tags": tags,
-                    }
-            else:
-                yield from _conll_ner_generator(file_path, self.config)
+            yield from _conll_ner_generator(file_path, self.config)
         elif self.config.task_type == "rte":
             if "assin2" in self.config.name:
                 yield from _assin2_generator(file_path, self.config)