Upload wikipedia.py with huggingface_hub

wikipedia.py

@@ -20,11 +20,15 @@
 import bz2
 import codecs
 import json
+import os
 import re
 import warnings
 import xml.etree.cElementTree as etree
 from urllib.parse import quote
 
+import pyarrow as pa
+import pyarrow.parquet as pq
+
 import datasets
 
 
@@ -905,7 +909,7 @@ class WikipediaConfig(datasets.BuilderConfig):
 _DATE = "20220301"
 
 
-class Wikipedia(datasets.BeamBasedBuilder):
+class Wikipedia(datasets.ArrowBasedBuilder):
     """Wikipedia dataset."""
 
     # Use mirror (your.org) to avoid download caps.
@@ -917,6 +921,8 @@ class Wikipedia(datasets.BeamBasedBuilder):
         )  # pylint:disable=g-complex-comprehension
         for lang in WIKIPEDIA_LANGUAGES
     ]
+    
+    BATCH_SIZE = 1000
 
     def _info(self):
         warnings.warn(
@@ -941,112 +947,115 @@ class Wikipedia(datasets.BeamBasedBuilder):
             supervised_keys=None,
             homepage="https://dumps.wikimedia.org",
             citation=_CITATION,
+            license=_LICENSE,
         )
 
-    def _split_generators(self, dl_manager, pipeline):
-        def _base_url(lang):
-            return _BASE_URL_TMPL.format(lang=lang.replace("-", "_"), date=self.config.date)
-
-        lang = self.config.language
-
-        info_url = _base_url(lang) + _INFO_FILE
-        # Use dictionary since testing mock always returns the same result.
-        downloaded_files = dl_manager.download_and_extract({"info": info_url})
-
-        xml_urls = []
-        total_bytes = 0
-        with open(downloaded_files["info"], encoding="utf-8") as f:
-            dump_info = json.load(f)
-        multistream_dump_info = dump_info["jobs"]["articlesmultistreamdump"]
-        assert (
-            multistream_dump_info["status"] == "done"
-        ), "Specified dump (%s) multistream status is not 'done': %s" % (
-            _base_url(lang),
-            multistream_dump_info["status"],
-        )
+    def _split_generators(self, dl_manager):
+        processed_data_dir = os.path.join("data", self.config.name)
+        is_processed = os.path.exists(processed_data_dir)
+        if is_processed:
+            parquet_urls = sorted(os.path.join(processed_data_dir, parquet_file) for parquet_file in os.listdir(processed_data_dir))
+            # Use dictionary since testing mock always returns the same result.
+            downloaded_files = dl_manager.download({"parquet": parquet_urls})
+            files = downloaded_files["parquet"]
+        else:
+            def _base_url(lang):
+                return _BASE_URL_TMPL.format(lang=lang.replace("-", "_"), date=self.config.date)
 
-        for fname, info in multistream_dump_info["files"].items():
-            if ".xml" not in fname:
-                continue
-            total_bytes += info["size"]
-            xml_urls.append(_base_url(lang) + fname)
+            lang = self.config.language
+
+            info_url = _base_url(lang) + _INFO_FILE
+            # Use dictionary since testing mock always returns the same result.
+            downloaded_files = dl_manager.download_and_extract({"info": info_url})
+
+            xml_urls = []
+            total_bytes = 0
+            with open(downloaded_files["info"], encoding="utf-8") as f:
+                dump_info = json.load(f)
+            multistream_dump_info = dump_info["jobs"]["articlesmultistreamdump"]
+            assert (
+                multistream_dump_info["status"] == "done"
+            ), "Specified dump (%s) multistream status is not 'done': %s" % (
+                _base_url(lang),
+                multistream_dump_info["status"],
+            )
+
+            for fname, info in multistream_dump_info["files"].items():
+                if ".xml" not in fname:
+                    continue
+                total_bytes += info["size"]
+                xml_urls.append(_base_url(lang) + fname)
 
             # Use dictionary since testing mock always returns the same result.
-        downloaded_files = dl_manager.download({"xml": xml_urls})
-        if not pipeline.is_local():
-            downloaded_files = dl_manager.ship_files_with_pipeline(downloaded_files, pipeline)
+            downloaded_files = dl_manager.download({"xml": xml_urls})
+            files = downloaded_files["xml"]
 
         return [
             datasets.SplitGenerator(  # pylint:disable=g-complex-comprehension
-                name=datasets.Split.TRAIN, gen_kwargs={"filepaths": downloaded_files["xml"], "language": lang}
+                name=datasets.Split.TRAIN, gen_kwargs={"files": files, "is_processed": is_processed}
             )
         ]
 
-    def _build_pcollection(self, pipeline, filepaths, language):
-        """Build PCollection of examples in the raw (text) form."""
-        import apache_beam as beam
-        import mwparserfromhell
-
-        def _extract_content(filepath):
-            """Extracts article content from a single WikiMedia XML file."""
-            logger.info("generating examples from = %s", filepath)
-            with beam.io.filesystems.FileSystems.open(filepath) as f:
-                f = bz2.BZ2File(filename=f)
-                # Workaround due to: https://github.com/tensorflow/tensorflow/issues/33563
-                utf_f = codecs.getreader("utf-8")(f)
-                context = etree.iterparse(utf_f, events=("end",))
-                for unused_event, elem in context:
-                    if not elem.tag.endswith("page"):
+    def _generate_tables(self, files, is_processed):
+        if is_processed:
+            batch_idx = 0
+            for file in files:
+                with open(file, "rb") as f:
+                    f = pq.ParquetFile(f)  
+                    for batch in f.iter_batches(batch_size=self.BATCH_SIZE):
+                        yield batch_idx, pa.Table.from_batches([batch])
+                        batch_idx += 1
+        else:           
+            batch = []
+            batch_idx = 0
+            for file in files:
+                logger.info("generating examples from = %s", file)
+                for content in _extract_content(file):
+                    example = _clean_content(content, self.config.language)
+                    if example is None:
                         continue
-                    namespace = elem.tag[:-4]
-                    title = elem.find(f"./{namespace}title").text
-                    ns = elem.find(f"./{namespace}ns").text
-                    id_ = elem.find(f"./{namespace}id").text
-                    red_ = elem.find(f"./{namespace}redirect")
-
-                    # Filter pages that are not in the "main" namespace.
-                    if ns != "0":
-                        elem.clear()
-                        continue
-
-                    raw_content = elem.find(f"./{namespace}revision/{namespace}text").text
-                    elem.clear()
+                    batch.append(example)
+                    if len(batch) >= self.BATCH_SIZE:
+                        pa_table = pa.Table.from_pylist(batch)
+                        yield batch_idx, pa_table
+                        batch = []
+                        batch_idx += 1
 
-                    # Filter redirects.
-                    if raw_content is None or red_ is not None:
-                        beam.metrics.Metrics.counter(language, "filtered-redirects").inc()
-                        continue
+            if batch:
+                pa_table = pa.Table.from_pylist(batch)
+                yield batch_idx, pa_table
 
-                    beam.metrics.Metrics.counter(language, "extracted-examples").inc()
-                    yield (id_, title, raw_content)
 
-        def _clean_content(inputs, language):
-            """Cleans raw wikicode to extract text."""
-            id_, title, raw_content = inputs
-            try:
-                text = _parse_and_clean_wikicode(raw_content, parser=mwparserfromhell, language=language)
-            except (mwparserfromhell.parser.ParserError) as e:
-                beam.metrics.Metrics.counter(language, "parser-error").inc()
-                logger.error("mwparserfromhell ParseError: %s", e)
-                return
-
-            if not text:
-                beam.metrics.Metrics.counter(language, "empty-clean-examples").inc()
-                return
+def _extract_content(file):
+    """Extracts article content from a single WikiMedia XML file."""
+    print("Extracting content from", file)
+    with open(file, "rb") as f:
+        f = bz2.BZ2File(filename=f)
+        # Workaround due to: https://github.com/tensorflow/tensorflow/issues/33563
+        utf_f = codecs.getreader("utf-8")(f)
+        context = etree.iterparse(utf_f, events=("end",))
+        for unused_event, elem in context:
+            if not elem.tag.endswith("page"):
+                continue
+            namespace = elem.tag[:-4]
+            title = elem.find(f"./{namespace}title").text
+            ns = elem.find(f"./{namespace}ns").text
+            id_ = elem.find(f"./{namespace}id").text
+            red_ = elem.find(f"./{namespace}redirect")
 
-            url = _construct_url(title, language)
+            # Filter pages that are not in the "main" namespace.
+            if ns != "0":
+                elem.clear()
+                continue
 
-            beam.metrics.Metrics.counter(language, "cleaned-examples").inc()
+            raw_content = elem.find(f"./{namespace}revision/{namespace}text").text
+            elem.clear()
 
-            yield id_, {"id": id_, "url": url, "title": title, "text": text}
+            # Filter redirects.
+            if raw_content is None or red_ is not None:
+                continue
 
-        return (
-            pipeline
-            | "Initialize" >> beam.Create(filepaths)
-            | "Extract content" >> beam.FlatMap(_extract_content)
-            | "Distribute" >> beam.transforms.Reshuffle()
-            | "Clean content" >> beam.FlatMap(_clean_content, language=language)
-        )
+            yield id_, title, raw_content
 
 
 def _parse_and_clean_wikicode(raw_content, parser, language):
@@ -1111,3 +1120,22 @@ def _parse_and_clean_wikicode(raw_content, parser, language):
 def _construct_url(title, language):
     # See: https://meta.wikimedia.org/wiki/Help:URL
     return f"https://{language}.wikipedia.org/wiki/{quote(title)}"
+
+
+def _clean_content(inputs, language):
+    """Cleans raw wikicode to extract text."""
+    import mwparserfromhell
+
+    id_, title, raw_content = inputs
+    try:
+        text = _parse_and_clean_wikicode(raw_content, parser=mwparserfromhell, language=language)
+    except (mwparserfromhell.parser.ParserError) as e:
+        logger.error("mwparserfromhell ParseError: %s", e)
+        return
+
+    if not text:
+        return
+
+    url = _construct_url(title, language)
+
+    return {"id": id_, "url": url, "title": title, "text": text}