Streaming dataset generation

The current wikipedia.py script spawns a process for every raw data file and keeps the entire dataset in memory until the end of the process. With 100+ files in the input dataset, it's near impossible to build this with lower resourced machines.

This PR modifies wikipedia.py to support streaming dataset generation as follows:

- Yield each Wikipedia article vs reading entire files into memory
- Only spawn up to os.cpu_count() processes
- Use shared queues, with a limited buffer, between the main process and worker processes
- Yield each processed article to iteratively build the dataset

With these changes, the process will scale based on the resources available.

wikipedia.py

@@ -20,14 +20,15 @@
 import bz2
 import codecs
 import json
+import os
 import re
 import xml.etree.cElementTree as etree
+
+from multiprocessing import Process, Queue
 from urllib.parse import quote
-import mwparserfromhell
-from multiprocess import Process, Manager
-from tqdm import tqdm
 
 import datasets
+import mwparserfromhell
 
 
 logger = datasets.logging.get_logger(__name__)
@@ -904,8 +905,8 @@ class WikipediaConfig(datasets.BuilderConfig):
         self.language = language
 
 
-_DATE = "20220301"
-
+_DATE = "20240101"
+_COMPLETE = 1
 
 class Wikipedia(datasets.GeneratorBasedBuilder):
     """Wikipedia dataset."""
@@ -967,9 +968,8 @@ class Wikipedia(datasets.GeneratorBasedBuilder):
 
             # Use dictionary since testing mock always returns the same result.
 
-        print("Dowloading Wikipedia dump")
+        # Download Wikipedia files
         downloaded_files = dl_manager.download({"xml": xml_urls})
-        print("Finished downloading Wikipedia dump")
 
         return [
             datasets.SplitGenerator(  # pylint:disable=g-complex-comprehension
@@ -983,7 +983,6 @@ class Wikipedia(datasets.GeneratorBasedBuilder):
         def _extract_content(filepath):
             """Extracts article content from a single WikiMedia XML file."""
             logger.info("generating examples from = %s", filepath)
-            content = []
             f = bz2.BZ2File(filename=filepath)
             # Workaround due to: https://github.com/tensorflow/tensorflow/issues/33563
             utf_f = codecs.getreader("utf-8")(f)
@@ -991,6 +990,7 @@ class Wikipedia(datasets.GeneratorBasedBuilder):
             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
@@ -1009,8 +1009,7 @@ class Wikipedia(datasets.GeneratorBasedBuilder):
                 if raw_content is None or red_ is not None:
                     continue
 
-                content.append((id_, title, raw_content))
-            return content
+                yield (id_, title, raw_content)
 
         def _clean_content(inputs, language):
             """Cleans raw wikicode to extract text."""
@@ -1028,28 +1027,55 @@ class Wikipedia(datasets.GeneratorBasedBuilder):
 
             return id_, {"id": id_, "url": url, "title": title, "text": text}
 
-        print("Parsing and cleaning Wikipedia examples")
-        with Manager() as manager:
-            examples = manager.list()
-            processes = []
-            for filepath in filepaths:
-                def parse_and_clean(examples):
-                    content = _extract_content(filepath)
-                    for obj in tqdm(content):
-                        examples.append(_clean_content(obj, language=language))
-                p = Process(target=parse_and_clean, args=(examples,))
-                p.start()
-                processes.append(p)
-
-            for p in processes:
-                p.join()
-
-            print("Parsed and cleaned Wikipedia examples")
-
-            for example in examples:
-                if example is not None:
-                    yield example
+        # Create queues, limit size of output queue
+        inputs, outputs = Queue(), Queue(30000)
 
+        def execute(inputs, outputs):
+            try:
+                # Process until inputs queue is exhausted
+                while not inputs.empty():
+                    batch, filepath = [], inputs.get()
+                    for obj in _extract_content(filepath):
+                        batch.append(_clean_content(obj, language=language))
+                        if len(batch) == 1024:
+                            outputs.put(batch)
+                            batch = []
+
+                    if batch:
+                        outputs.put(batch)
+
+            finally:
+                # Write message that process is complete
+                outputs.put(_COMPLETE)
+
+        for filepath in filepaths:
+            inputs.put(filepath)
+
+        # Start worker processes
+        processes = []
+        for _ in range(min(len(filepaths), os.cpu_count())):
+            process = Process(target=execute, args=(inputs, outputs))
+            process.start()
+            processes.append(process)
+
+        # Read output from worker processes
+        empty, complete = False, 0
+        while not empty:
+            # Get next result
+            result = outputs.get()
+
+            # Mark process as complete if all workers are complete and output queue is empty
+            if result == _COMPLETE:
+                complete += 1
+                empty = len(processes) == complete and outputs.empty()
+
+            elif result:
+                for r in result:
+                    if r is not None:
+                        yield r
+
+        for process in processes:
+            process.join()
 
 def _parse_and_clean_wikicode(raw_content, parser, language):
     """Strips formatting and unwanted sections from raw page content."""