Upload liv4ever.py

liv4ever.py

@@ -1,4 +1,3 @@
-# coding=utf-8
 # Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,14 +11,19 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+# TODO: Address all TODOs and remove all explanatory comments
 """Liv4ever dataset."""
 
 
+import csv
 import json
+import os
 
 import datasets
 
 
+# TODO: Add BibTeX citation
+# Find for instance the citation on arxiv or on the dataset repo/website
 _CITATION = """\
 @inproceedings{rikters-etal-2022,
     title = "Machine Translation for Livonian: Catering for 20 Speakers",
@@ -35,7 +39,8 @@ _CITATION = """\
 }
 """
 
-
+# TODO: Add description of the dataset here
+# You can copy an official description
 _DESCRIPTION = """\
 Livonian is one of the most endangered languages in Europe with just a tiny handful of speakers and virtually no publicly available corpora. 
 In this paper we tackle the task of developing neural machine translation (NMT) between Livonian and English, with a two-fold aim: on one hand, 
@@ -52,88 +57,118 @@ Fields:
 - liv: sentence in Livonian
 """
 
-_HOMEPAGE = "https://huggingface.co/datasets/tartuNLP/liv4ever-data"
+# TODO: Add a link to an official homepage for the dataset here
+_HOMEPAGE = "https://huggingface.co/datasets/tartuNLP/liv4ever"
 
+# TODO: Add the licence for the dataset here if you can find it
 _LICENSE = "CC BY-NC-SA 4.0"
 
-_REPO = "https://huggingface.co/datasets/tartuNLP/liv4ever/raw/main/"
-
-_URLs = {
-    "train": _REPO + "train.json",
-    "dev": _REPO + "dev.json",
-    "test": _REPO + "test.json",
+# TODO: Add link to the official dataset URLs here
+# The HuggingFace Datasets library doesn't host the datasets but only points to the original files.
+# This can be an arbitrary nested dict/list of URLs (see below in `_split_generators` method)
+_URLS = {
+    "train": "https://huggingface.co/datasets/tartuNLP/liv4ever/raw/main/train.json",
+    "dev": "https://huggingface.co/datasets/tartuNLP/liv4ever/raw/main/dev.json",
+    "test": "https://huggingface.co/datasets/tartuNLP/liv4ever/raw/main/test.json",
 }
 
 
+# TODO: Name of the dataset usually match the script name with CamelCase instead of snake_case
 class liv4ever(datasets.GeneratorBasedBuilder):
     """Liv4ever dataset."""
 
     VERSION = datasets.Version("1.0.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
+
+    # You will be able to load one or the other configurations in the following list with
+    # data = datasets.load_dataset('my_dataset', 'train')
+    # data = datasets.load_dataset('my_dataset', 'dev')
+    BUILDER_CONFIGS = [
+        datasets.BuilderConfig(name="train", version=VERSION, description="This part of my dataset covers a first domain"),
+        datasets.BuilderConfig(name="dev", version=VERSION, description="This part of my dataset covers a second domain"),
+    ]
+
+    DEFAULT_CONFIG_NAME = "train"  # 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
         features = datasets.Features(
             {
                 "source": datasets.Value("string"),
                 "en": datasets.Value("string"),
-                "liv": datasets.Value("string"),
+                "liv": datasets.Value("string")
+                # These are the features of your dataset like images, labels ...
             }
         )
         return datasets.DatasetInfo(
+            # This is the description that will appear on the datasets page.
             description=_DESCRIPTION,
-            features=features,
-            supervised_keys=None,
+            # This defines the different columns of the dataset and their types
+            features=features,  # Here we define them above because they are different between the two configurations
+            # If there's a common (input, target) tuple from the features, uncomment supervised_keys line below and
+            # specify them. They'll be used if as_supervised=True in builder.as_dataset.
+            # supervised_keys=("sentence", "label"),
+            # Homepage of the dataset for documentation
             homepage=_HOMEPAGE,
+            # License for the dataset if available
             license=_LICENSE,
+            # Citation for the dataset
             citation=_CITATION,
         )
 
     def _split_generators(self, dl_manager):
-        """Returns SplitGenerators."""
-        data_dir = dl_manager.download_and_extract(_URLs)
-
+        # TODO: This method is tasked with downloading/extracting the data and defining the splits depending on the configuration
+        # If several configurations are possible (listed in BUILDER_CONFIGS), the configuration selected by the user is in self.config.name
+
+        # 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]
+        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": data_dir["train"],
+                    "filepath": os.path.join(data_dir, "train.jsonl"),
                     "split": "train",
                 },
             ),
             datasets.SplitGenerator(
                 name=datasets.Split.TEST,
-                gen_kwargs={"filepath": data_dir["test"], "split": "test"},
+                # These kwargs will be passed to _generate_examples
+                gen_kwargs={
+                    "filepath": os.path.join(data_dir, "test.jsonl"),
+                    "split": "test"
+                },
             ),
             datasets.SplitGenerator(
                 name=datasets.Split.VALIDATION,
+                # These kwargs will be passed to _generate_examples
                 gen_kwargs={
-                    "filepath": data_dir["dev"],
+                    "filepath": os.path.join(data_dir, "dev.jsonl"),
                     "split": "dev",
                 },
             ),
         ]
 
+    # method parameters are unpacked from `gen_kwargs` as given in `_split_generators`
     def _generate_examples(self, filepath, split):
-        """Yields examples."""
-
+        # 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:
-            data = json.load(f)
-                
-                
-            for dialogue in data:
-                source = dialogue["source"]
-                sentences = dialogue["sentences"]
-                
-                i=0
-
-                for turn in sentences:
-                    i = i+1
-                    sent_no = i
-                    en = dialogue["en"]
-                    liv = dialogue["liv"]
-
-                    yield f"{sent_no}", {
-                        "no": sent_no,
-                        "source": source,
-                        "en": en,
-                        "liv": liv,
-                    }
+            for key, row in enumerate(f):
+                data = json.loads(row)
+                # Yields examples as (key, example) tuples
+                yield key, {
+                    "source": data["source"],
+                    "en": data["en"],
+                    "liv": data["liv"],
+                }