Added comments

opusparcus.py

@@ -106,7 +106,6 @@ class Opusparcus(datasets.GeneratorBasedBuilder):
                 "sent2": datasets.Value("string"),
                 "annot_score": datasets.Value("float"),
                 "gem_id": datasets.Value("string"),
-                #"quality": datasets.Value("uint8")
             }
         )
 
@@ -130,24 +129,37 @@ class Opusparcus(datasets.GeneratorBasedBuilder):
 
     def _split_generators(self, dl_manager):
         """Returns SplitGenerators."""
-        # 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
+        # This method is tasked with downloading/extracting the data
+        # and defining the splits depending on the configuration.
+        # Several configurations are possible (listed in
+        # BUILDER_CONFIGS), and the configuration selected by the user
+        # is in self.config.name, which consists of two fields
+        # separated by a period, containing the values of
+        # self.config.lang and self.config.quality.
 
+        # Select which file of the training data contains the matching data:
         if self.config.quality < 70:
             # We need to retrieve the largest training set file
             # containing the full training set for the desired language
             _URLs["train"] = "train_{0}.60.jsonl.bz2".format(self.config.lang)
+
         elif self.config.quality <= 95:
             # We can do with a smaller version of the training set
             # for the desired language
             _URLs["train"] = "train_{0}.70.jsonl.bz2".format(self.config.lang)
 
         # Otherwise, if the desired quality is above 95, we do not
-        # download any training data, because there is no matching data
+        # download any training data, because there is no matching data.
+        # The validation and test sets are so small that we do not perform
+        # any filtering or optimization at this stage.
             
+        # dl_manager is a datasets.download.DownloadManager, which
+        # downloads and extracts the 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.)
         data_dir = dl_manager.download_and_extract(_URLs)
 
         splits = [
@@ -193,8 +205,13 @@ class Opusparcus(datasets.GeneratorBasedBuilder):
             ),
         ]            
 
+        # If the desired quality value is 100, no subset of the
+        # training set is good enough, and we only produce validation
+        # and test sets, in order to save space and time.
+            
         if self.config.quality <= 95:
-            # We do have training data as well
+            # In this case there is matching training data, so we produce
+            # a train split.
             splits.append(
                 datasets.SplitGenerator(
                     name=datasets.Split.TRAIN,
@@ -211,43 +228,56 @@ class Opusparcus(datasets.GeneratorBasedBuilder):
         return splits
 
     def _generate_examples(
-            self, lang, quality, filepath, split  # method parameters are unpacked from `gen_kwargs` as given in `_split_generators`
+            self, lang, quality, filepath, split
+            # method parameters are unpacked from `gen_kwargs` as given in
+            # `_split_generators`
     ):
-
         """ Yields examples as (key, example) tuples. """
-        # This method handles input defined in _split_generators to yield (key, example) tuples from the dataset.
+        # This method handles input defined in _split_generators to
+        # yield (key, example) tuples from the dataset.
         # The `key` is here for legacy reason (tfds) and is not important in itself.
+
         if split == datasets.Split.TRAIN:
+            # Training sets are in compressed bz2 files.
+            # They contain a field "quality" missing from the validation and test sets.
+            # We also know that this file only contains the desired language,
+            # because for the training sets the languages are in separate
+            # files, and only the desired language has been downloaded. 
             with bz2.open(filepath, "rt", encoding="utf-8") as f:
-                # We know that this file only contains the desired language,
-                # because for the training sets the languages are in separate
-                # files, and only the desired language has been downloaded 
                 for id_, row in enumerate(f):
                     data = json.loads(row)
                     if data["quality"] < quality:
-                        # The rest of this file contains too low quality data
+                        # The rest of this file contains too low quality data,
+                        # because the data is sorted best first
                         break
                     yield id_, {
                         "lang": data["lang"],
                         "sent1": data["sent1"],
                         "sent2": data["sent2"],
-                        "annot_score": 0.0,
+                        "annot_score": 0.0,   # means there is no annotation
                         "gem_id": data["gem_id"],
-                        #"quality": data["quality"],
                     }
         else:
+            # The validation and test sets are in jsonl files.
+            # They contain the fields "lang" and "quality" that we filter on.
+            # If we ask for the full sets, we will keep all data entries, also
+            # the sentence pairs that were not considered paraphrases by the
+            # annotators:
             keep_all = (split == "validation.full" or split == "test.full")
             with open(filepath, encoding="utf-8") as f:
                 for id_, row in enumerate(f):
                     data = json.loads(row)
-                    if data["lang"] == lang:
+                    if data["lang"] == lang: # only keep desired language
                         if keep_all or data["annot_score"] >= 3.0:
+                            # for full sets keep all;
+                            # for standard test and validation sets, keep only
+                            # the paraphrases (annot_score >= 3.0 means "good
+                            # or mostly good example of paraphrases")
                             yield id_, {
                                 "lang": data["lang"],
                                 "sent1": data["sent1"],
                                 "sent2": data["sent2"],
                                 "annot_score": data["annot_score"],
                                 "gem_id": data["gem_id"],
-                                #"quality": 100,
                             }