Prototype Init (MVP)

super_eurlex.py

@@ -18,26 +18,18 @@
 import csv
 import json
 import os
+import pandas as pd
 
 import datasets
 
 
 # TODO: Add BibTeX citation
 # Find for instance the citation on arxiv or on the dataset repo/website
-_CITATION = """\
-@InProceedings{huggingface:dataset,
-title = {A great new dataset},
-author={huggingface, Inc.
-},
-year={2020}
-}
-"""
+_CITATION = """ """
 
 # TODO: Add description of the dataset here
 # You can copy an official description
-_DESCRIPTION = """\
-This new dataset is designed to solve this great NLP task and is crafted with a lot of care.
-"""
+_DESCRIPTION = """ """
 
 # TODO: Add a link to an official homepage for the dataset here
 _HOMEPAGE = ""
@@ -52,18 +44,64 @@ _URLS = {
     "first_domain": "https://huggingface.co/great-new-dataset-first_domain.zip",
     "second_domain": "https://huggingface.co/great-new-dataset-second_domain.zip",
 }
+AVAILABLE_LANGUAGES=['DE']#, 'EN'
+SECTORS=['1']#, '1', '2', '3', '4', '5', '6', '7', '8', '9', 'C', 'E']
+AVAILABLE_FEATURES={
+    '1': datasets.Features({
+         'celex_id': datasets.Value("string"),
+         'text_html_raw': datasets.Value("string"),
+         'text_html_cleaned': datasets.Value("string"),
+         'text_cleaned': datasets.Value("string"),
+         'form': datasets.Sequence(datasets.Value("string")),
+         'subject_matter': datasets.Sequence(datasets.Value("string")),
+         'current_consolidated_version': datasets.Sequence(datasets.Value("string")),
+         'harmonisation_of_customs_law_community_transit': datasets.Sequence(datasets.Value("string")),
+         'harmonisation_of_customs_law_customs_territory': datasets.Sequence(datasets.Value("string")),
+         'harmonisation_of_customs_law_value_for_customs_purposes': datasets.Sequence(datasets.Value("string")),
+         'directory_code': datasets.Sequence(datasets.Value("string")),
+         'eurovoc': datasets.Sequence(datasets.Value("string")),
+         'customs_duties_community_tariff_quotas': datasets.Sequence(datasets.Value("string")),
+         'customs_duties_authorisation_to_defer_application_of_cct': datasets.Sequence(datasets.Value("string")),
+         'harmonisation_of_customs_law_various': datasets.Sequence(datasets.Value("string")),
+         'customs_duties_suspensions': datasets.Sequence(datasets.Value("string"))})
+}
+SECTOR_DESCRIPTIONS={
+    '1':""
+}
 
 
+class SuperEurlexConfig(datasets.BuilderConfig):
+    """BuilderConfig for SuperGLUE."""
+
+    def __init__(self, sector, language, features, citation, url, **kwargs):
+        """BuilderConfig for SuperGLUE.
+
+        Args:
+        sector: sector of the wanted data
+        language: the language code for the language in which the text shall
+            be written in
+        features: *list[string]*, list of the features that will appear in the
+            feature dict.
+        citation: *string*, citation for the data set.
+        url: *string*, url for information about the data set.
+        **kwargs: keyword arguments forwarded to super.
+        """
+        name=sector+'.'+language
+        super().__init__(name=name, version=datasets.Version("0.1.0"), **kwargs)
+        self.features = features
+        self.language = language
+        self.sector = sector
+        self.text_data_url = f"text_data/{language}/{sector}.jsonl"
+        self.meta_data_url = f"meta_data/{sector}.jsonl"
+        self.citation = citation
+        self.url = url
+
 # TODO: Name of the dataset usually matches the script name with CamelCase instead of snake_case
-class NewDataset(datasets.GeneratorBasedBuilder):
+class SuperEurlex(datasets.GeneratorBasedBuilder):
     """TODO: Short description of my dataset."""
 
     VERSION = datasets.Version("1.1.0")
 
-    # This is an example of a dataset with multiple configurations.
-    # If you don't want/need to define several sub-sets in your dataset,
-    # just remove the BUILDER_CONFIG_CLASS and the BUILDER_CONFIGS attributes.
-
     # If you need to make complex sub-parts in the datasets with configurable options
     # You can create your own builder configuration class to store attribute, inheriting from datasets.BuilderConfig
     # BUILDER_CONFIG_CLASS = MyBuilderConfig
@@ -71,34 +109,24 @@ class NewDataset(datasets.GeneratorBasedBuilder):
     # You will be able to load one or the other configurations in the following list with
     # data = datasets.load_dataset('my_dataset', 'first_domain')
     # data = datasets.load_dataset('my_dataset', 'second_domain')
+
     BUILDER_CONFIGS = [
-        datasets.BuilderConfig(name="first_domain", version=VERSION, description="This part of my dataset covers a first domain"),
-        datasets.BuilderConfig(name="second_domain", version=VERSION, description="This part of my dataset covers a second domain"),
-    ]
+        SuperEurlexConfig(#version=VERSION,
+                          sector=sect,
+                          language=lang,
+                          description=SECTOR_DESCRIPTIONS[sect],
+                          features=AVAILABLE_FEATURES[sect],
+                          citation=_CITATION,
+                          url=_HOMEPAGE)
+        for lang in AVAILABLE_LANGUAGES for sect in SECTORS
+        ]
 
-    DEFAULT_CONFIG_NAME = "first_domain"  # It's not mandatory to have a default configuration. Just use one if it make sense.
+    DEFAULT_CONFIG_NAME = "3.DE"  # It's not mandatory to have a default configuration. Just use one if it make sense.
 
     def _info(self):
         # TODO: This method specifies the datasets.DatasetInfo object which contains informations and typings for the dataset
-        if self.config.name == "first_domain":  # This is the name of the configuration selected in BUILDER_CONFIGS above
-            features = datasets.Features(
-                {
-                    "sentence": datasets.Value("string"),
-                    "option1": datasets.Value("string"),
-                    "answer": datasets.Value("string")
-                    # These are the features of your dataset like images, labels ...
-                }
-            )
-        else:  # This is an example to show how to have different features for "first_domain" and "second_domain"
-            features = datasets.Features(
-                {
-                    "sentence": datasets.Value("string"),
-                    "option2": datasets.Value("string"),
-                    "second_domain_answer": datasets.Value("string")
-                    # These are the features of your dataset like images, labels ...
-                }
-            )
-        return datasets.DatasetInfo(
+        features = AVAILABLE_FEATURES[self.config.sector]
+        info = datasets.DatasetInfo(
             # This is the description that will appear on the datasets page.
             description=_DESCRIPTION,
             # This defines the different columns of the dataset and their types
@@ -113,6 +141,7 @@ class NewDataset(datasets.GeneratorBasedBuilder):
             # Citation for the dataset
             citation=_CITATION,
         )
+        return info
 
     def _split_generators(self, dl_manager):
         # TODO: This method is tasked with downloading/extracting the data and defining the splits depending on the configuration
@@ -121,52 +150,56 @@ class NewDataset(datasets.GeneratorBasedBuilder):
         # dl_manager is a datasets.download.DownloadManager that can be used to download and extract URLS
         # It can accept any type or nested list/dict and will give back the same structure with the url replaced with path to local files.
         # By default the archives will be extracted and a path to a cached folder where they are extracted is returned instead of the archive
-        urls = _URLS[self.config.name]
+        urls = {'text': self.config.text_data_url,
+                'meta': self.config.meta_data_url} #_URLS[self.config.name]
         data_dir = dl_manager.download_and_extract(urls)
         return [
             datasets.SplitGenerator(
                 name=datasets.Split.TRAIN,
                 # These kwargs will be passed to _generate_examples
                 gen_kwargs={
-                    "filepath": os.path.join(data_dir, "train.jsonl"),
-                    "split": "train",
+                    "text": data_dir['text'],
+                    "meta": data_dir['meta'],
+                    "language": self.config.language,
+                    "sector": self.config.sector,
+                    'split': 'train'
                 },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                # These kwargs will be passed to _generate_examples
-                gen_kwargs={
-                    "filepath": os.path.join(data_dir, "dev.jsonl"),
-                    "split": "dev",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                # These kwargs will be passed to _generate_examples
-                gen_kwargs={
-                    "filepath": os.path.join(data_dir, "test.jsonl"),
-                    "split": "test"
-                },
-            ),
+            )
         ]
 
     # method parameters are unpacked from `gen_kwargs` as given in `_split_generators`
-    def _generate_examples(self, filepath, split):
+    def _generate_examples(self, text, meta, sector, language, split):
         # TODO: This method handles input defined in _split_generators to yield (key, example) tuples from the dataset.
         # The `key` is for legacy reasons (tfds) and is not important in itself, but must be unique for each example.
-        with open(filepath, encoding="utf-8") as f:
-            for key, row in enumerate(f):
-                data = json.loads(row)
-                if self.config.name == "first_domain":
-                    # Yields examples as (key, example) tuples
-                    yield key, {
-                        "sentence": data["sentence"],
-                        "option1": data["option1"],
-                        "answer": "" if split == "test" else data["answer"],
-                    }
-                else:
-                    yield key, {
-                        "sentence": data["sentence"],
-                        "option2": data["option2"],
-                        "second_domain_answer": "" if split == "test" else data["second_domain_answer"],
-                    }
+        print(text)
+        print(meta)
+        print(sector)
+        print(split)
+        print(sector)
+
+        print("Reading Text Data...")
+        text_data = pd.read_json(text, lines=True)
+        text_data['celex_id'] = text_data['celex_id'].apply(lambda x: x[0] if isinstance(x,list) else x)
+        print("Reading Meta Data...")
+        meta_data = pd.read_json(meta, lines=True)
+        meta_data['celex_id'] = meta_data['celex_id'].apply(lambda x: x[0] if isinstance(x, list) else x)
+        print("Combining Text & Meta Data...")
+        combined_data = pd.merge(text_data, meta_data, on='celex_id')
+        print("Converting To final dataset...")
+        dataset = datasets.Dataset.from_pandas(combined_data)
+        dataset = dataset.remove_columns('__index_level_0__')#.cache_files()
+        for i, sample in enumerate(dataset):
+            yield i, sample
+
+
+
+print("Hello World")
+if __name__ == '__main__':
+    import datasets as ds
+    import sys
+    print(sys.argv[0])
+    dataset = ds.load_dataset(sys.argv[0],'1.DE')
+    print(dataset)
+    for sample in dataset['train']:
+        continue
+        #print(sample)

text_data/DE/0.zip

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