simplify interface

RedPajama-Data-V2.py

@@ -21,16 +21,16 @@ import datasets
 import traceback
 import os
 import gzip
+from typing import List
 
 logger = datasets.logging.get_logger(__name__)
 
 _DESCRIPTION = """\
-RedPajama V2 is a Data Foundation of Web Text Documents with Quality Annotations.
+RedPajama V2: an Open Dataset for Training Large Language Models
 """
 
 _URL_BASE = 'https://data.together.xyz/redpajama-data-v2/v1.0.0'
 _LANGUAGES = ("en", "de", "fr", "es", "it")
-_SAMPLE_SNAPSHOT_ID = "2023-06"
 _LISTINGS_PATTERN = "listings/{language}-{snapshot}-{partition}.txt"
 
 _CC_SNAPSHOT_IDS = (
@@ -124,120 +124,53 @@ _CC_SNAPSHOT_IDS = (
 class RedPajamaDataV2Config(datasets.BuilderConfig):
     """BuilderConfig for RedPajama."""
 
-    def __init__(self, *args, language, partition, snapshots, **kwargs):
+    def __init__(self, *args, **kwargs):
         """BuilderConfig for RedPajama.
         Args:
           **kwargs: keyword arguments forwarded to super.
         """
         super(RedPajamaDataV2Config, self).__init__(**kwargs)
-        self.partition = partition
-        self.snapshots = snapshots
-        self.language = language
-
-
-_BUILDER_CONFIGS = [
-    RedPajamaDataV2Config(
-        name=f'_sample',
-        partition='sample',
-        snapshots=None,
-        language=None,
-        version=datasets.Version("1.0.0", ""),
-        description=f"RedPajamaV2 Sample",
-    ),
-    # this one is just an alias for the sample
-    RedPajamaDataV2Config(
-        name=f'sample',
-        partition='sample',
-        snapshots=None,
-        language=None,
-        version=datasets.Version("1.0.0", ""),
-        description=f"RedPajamaV2 Sample",
-    )
-]
-
-for lang in _LANGUAGES:
-    _BUILDER_CONFIGS.extend(
-        [
-            # single snapshot
-            RedPajamaDataV2Config(
-                name=f'{lang}-head-middle-{snapshot}',
-                partition='head_middle',
-                snapshots=[snapshot],
-                language=lang,
-                version=datasets.Version("1.0.0", ""),
-                description=f"RedPajamaV2 head-middle {lang}-{snapshot}",
-            )
-            for snapshot in _CC_SNAPSHOT_IDS
-        ] + [
-            # all snapshots
-            RedPajamaDataV2Config(
-                name=f'{lang}-head-middle-all',
-                partition='head_middle',
-                snapshots=_CC_SNAPSHOT_IDS,
-                language=lang,
-                version=datasets.Version("1.0.0", ""),
-                description=f"RedPajamaV2 head-middle {lang}"
-            )
-        ]
-    )
-
-    _BUILDER_CONFIGS.extend(
-        [
-            # single snapshot
-            RedPajamaDataV2Config(
-                name=f'{lang}-tail-{snapshot}',
-                partition='tail',
-                snapshots=[snapshot],
-                language=lang,
-                version=datasets.Version("1.0.0", ""),
-                description=f"RedPajamaV2 tail {lang}-{snapshot}",
-            )
-            for snapshot in _CC_SNAPSHOT_IDS
-        ] + [
-            # all snapshots
-            RedPajamaDataV2Config(
-                name=f'{lang}-tail-all',
-                partition='tail',
-                snapshots=_CC_SNAPSHOT_IDS,
-                language=lang,
-                version=datasets.Version("1.0.0", ""),
-                description=f"RedPajamaV2 tail {lang}"
-            )
-        ]
-    )
+        self.partition: str = kwargs.pop("partition", "all")
+        self.snapshots: List[str] = kwargs.pop("snapshots", _CC_SNAPSHOT_IDS)
+        self.languages: List[str] = kwargs.pop("languages", _LANGUAGES)
 
 
 class RedPajamaV2(datasets.GeneratorBasedBuilder):
     """ RedPajama V2: Quality annotated Web Text Documents. """
 
-    BUILDER_CONFIGS = _BUILDER_CONFIGS
+    BUILDER_CONFIGS = [
+        RedPajamaDataV2Config(
+            name='_sample',
+            version=datasets.Version("1.0.0", ""),
+            description=f"RedPajamaV2 Sample",
+        ),
+        # this one is just an alias for the sample
+        RedPajamaDataV2Config(
+            name='sample',
+            version=datasets.Version("1.0.0", ""),
+            description=f"RedPajamaV2 Sample",
+        ),
+
+        RedPajamaDataV2Config(
+            name='default',
+            version=datasets.Version("1.0.0", ""),
+            description=f"RedPajamaV2",
+        )
+    ]
 
     def _info(self):
-        if self.config.partition == "tail":
-            return datasets.DatasetInfo(
-                description=_DESCRIPTION,
-                features=datasets.Features(
-                    {
-                        "raw_content": datasets.Value("string"),
-                        "doc_id": datasets.Value("string"),
-                        "meta": datasets.Value("string"),
-                    }
-                ),
-                supervised_keys=None,
-            )
-        else:
-            return datasets.DatasetInfo(
-                description=_DESCRIPTION,
-                features=datasets.Features(
-                    {
-                        "raw_content": datasets.Value("string"),
-                        "doc_id": datasets.Value("string"),
-                        "meta": datasets.Value("string"),
-                        "quality_signals": datasets.Value("string")
-                    }
-                ),
-                supervised_keys=None,
-            )
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    "raw_content": datasets.Value("string"),
+                    "doc_id": datasets.Value("string"),
+                    "meta": datasets.Value("string"),
+                    "quality_signals": datasets.Value("string")
+                }
+            ),
+            supervised_keys=None,
+        )
 
     def _split_generators_sample(self, dl_manager):
         # fetch documents
@@ -248,15 +181,15 @@ class RedPajamaV2(datasets.GeneratorBasedBuilder):
             listings = [line.strip() for line in fd]
 
         # fetch documents
-        docs_files = dl_manager.download({
-            _SAMPLE_SNAPSHOT_ID: [
+        documents_files = dl_manager.download({
+            "head_middle": [
                 f"sample/documents/{lst}.json.gz" for lst in listings
             ]
         })
 
         # fetch quality signals
-        signals_files = dl_manager.download({
-            _SAMPLE_SNAPSHOT_ID: [
+        quality_signals_files = dl_manager.download({
+            "head_middle": [
                 f"sample/quality_signals/{lst}.signals.json.gz"
                 for lst in listings
             ]
@@ -266,74 +199,78 @@ class RedPajamaV2(datasets.GeneratorBasedBuilder):
             datasets.SplitGenerator(
                 name=datasets.Split.TRAIN,
                 gen_kwargs={
-                    "documents_files": {
-                        _SAMPLE_SNAPSHOT_ID: docs_files[_SAMPLE_SNAPSHOT_ID]
-                    },
-                    "quality_signals_files": {
-                        _SAMPLE_SNAPSHOT_ID: signals_files[_SAMPLE_SNAPSHOT_ID]
-                    }
+                    "listings_ids": {"head_middle": listings},
+                    "documents_files": documents_files,
+                    "quality_signals_files": quality_signals_files
                 }
             )
         ]
 
     def _split_generators_full(self, dl_manager):
-        url_lists = dl_manager.download_and_extract({
-            snapshot_id: _LISTINGS_PATTERN.format(
-                language=self.config.language,
-                snapshot=snapshot_id,
-                partition=self.config.partition,
-            )
-            for snapshot_id in self.config.snapshots
-        })
-
-        listings_ids = {}
-
-        for snapshot_id, listings_file in url_lists.items():
-            with open(listings_file, encoding="utf-8") as f:
-                listings_ids[snapshot_id] = [line.strip() for line in f]
-
-        # build urls pointing to documents
-        document_urls = {
-            snapshot_id: [
-                os.path.join(_URL_BASE, f"documents/{lst_id}.json.gz")
-                for lst_id in listings_ids[snapshot_id]
-            ]
-            for snapshot_id in self.config.snapshots
-        }
+        snapshots = getattr(self.config, 'snapshots', _CC_SNAPSHOT_IDS)
+        languages = getattr(self.config, 'languages', _LANGUAGES)
+        partition = getattr(self.config, 'partition', 'all')
+
+        partitions = {
+            "all": ["head_middle", "tail"]
+        }.get(partition, [partition])
+
+        # nested structure: partition -> urls
+        listings_files_urls = {}
+        for part in partitions:
+            listings_files_urls[part] = []
+            for snapshot_id in snapshots:
+                for lang in languages:
+                    listings_files_urls[part].append(
+                        _LISTINGS_PATTERN.format(
+                            language=lang,
+                            snapshot=snapshot_id,
+                            partition=part,
+                        )
+                    )
 
-        documents_files = dl_manager.download(document_urls)
+        # fetch listings from hub
+        listings_files = dl_manager.download_and_extract(listings_files_urls)
 
-        # build urls pointing to quality signals
-        if self.config.partition == "head_middle":
-            quality_signals_urls = {
-                snapshot_id: [
+        # fetch listings
+        listings_ids = {}
+        for part, part_listings_files in listings_files.items():
+            listings_ids[part] = []
+            for listings_file in part_listings_files:
+                with open(listings_file, encoding="utf-8") as f:
+                    listings_ids[part].extend([
+                        line.strip() for line in f
+                    ])
+
+        # build urls pointing to documents and quality signals
+        document_urls = {}
+        quality_signals_urls = {}
+        for part, part_listings_ids in listings_ids.items():
+            document_urls[part] = []
+            quality_signals_urls[part] = []
+            for lst_id in part_listings_ids:
+                document_urls[part].append(
+                    os.path.join(_URL_BASE, f"documents/{lst_id}.json.gz")
+                )
+                if part != "head_middle":
+                    continue
+
+                quality_signals_urls[part].append(
                     os.path.join(
-                        _URL_BASE,
-                        f"quality_signals/{lst_id}.signals.json.gz"
+                        _URL_BASE, f"quality_signals/{lst_id}.signals.json.gz"
                     )
-                    for lst_id in listings_ids[snapshot_id]
-                ]
-                for snapshot_id in self.config.snapshots
-            }
+                )
 
-            quality_signals_files = dl_manager.download(
-                quality_signals_urls
-            )
-        else:
-            quality_signals_files = {}
+        documents_files = dl_manager.download(document_urls)
+        quality_signals_files = dl_manager.download(quality_signals_urls)
 
         return [
             datasets.SplitGenerator(
                 name=datasets.Split.TRAIN,
                 gen_kwargs={
-                    "documents_files": {
-                        snapshot_id: documents_files[snapshot_id]
-                        for snapshot_id in self.config.snapshots
-                    },
-                    "quality_signals_files": {
-                        snapshot_id: quality_signals_files.get(snapshot_id)
-                        for snapshot_id in self.config.snapshots
-                    }
+                    "listings_ids": listings_ids,
+                    "documents_files": documents_files,
+                    "quality_signals_files": quality_signals_files
                 }
             )
         ]
@@ -344,58 +281,84 @@ class RedPajamaV2(datasets.GeneratorBasedBuilder):
 
         return self._split_generators_full(dl_manager)
 
-    def _generate_examples(self, documents_files, quality_signals_files):
-        """ This function returns examples """
-        snapshots = list(documents_files.keys())
-
+    def _generate_examples(
+            self, listings_ids, documents_files, quality_signals_files
+    ):
         key = 0
-        for snapshot in snapshots:
-            docs_files = documents_files[snapshot]
-            if self.config.partition in ("head_middle", "sample"):
-                qs_files = quality_signals_files[snapshot]
-            else:
-                qs_files = None
-
-            assert len(docs_files) == len(qs_files)
-
-            for doc_file, qs_file in zip(docs_files, qs_files):
-                with gzip.open(doc_file, "rt", encoding="utf-8") as df:
-                    with gzip.open(qs_file, "rt", encoding="utf-8") as qf:
-                        for row, (doc, qs) in enumerate(zip(df, qf)):
-
-                            try:
-                                doc = json.loads(doc)
-                                qs = json.loads(qs)
-                                doc_id = qs["id"]
-
-                                meta = {
-                                    "url": doc["url"],
-                                    "language": doc["language"],
-                                    "source_domain": doc["source_domain"],
-                                    "date_download": doc["date_download"],
-                                    "digest": doc["digest"],
-                                }
-
-                                if self.config.partition == "tail":
-                                    yield key, {
-                                        "raw_content": doc["raw_content"],
-                                        "doc_id": doc_id,
-                                        "meta": json.dumps(meta),
-                                    }
-                                else:
-                                    yield key, {
-                                        "raw_content": doc["raw_content"],
-                                        "doc_id": doc_id,
-                                        "meta": json.dumps(meta),
-                                        "quality_signals": json.dumps(
-                                            qs["quality_signals"]
-                                        ),
-                                    }
-                                key += 1
-                            except Exception as e:
-                                print(f'doc_file: {doc_file}')
-                                print(f'qs_file: {qs_file}')
-                                print(f'row: {row}')
-                                traceback.print_exc()
-
-                                raise e
+        for part in documents_files.keys():
+            part_docs_files = documents_files[part]
+            part_qs_files = quality_signals_files[part]
+            part_listings_ids = listings_ids[part]
+
+            if len(part_qs_files) == 0:
+                for sample in self._handle_tail_partition(
+                        part, part_docs_files, part_listings_ids
+                ):
+                    yield key, sample
+                    key += 1
+                continue
+
+            for sample in self._handle_head_middle_partition(
+                    part, part_docs_files, part_qs_files, part_listings_ids
+            ):
+                yield key, sample
+                key += 1
+
+    def _handle_tail_partition(self, part, docs_files, listings_ids):
+        for doc_file, listing_id in zip(docs_files, listings_ids):
+            with gzip.open(doc_file, "rt", encoding="utf-8") as df:
+                for row, doc in enumerate(df):
+                    doc_id = f"{listing_id}.json.gz/{row}"
+                    try:
+                        yield self.handle_record(part, doc_id, doc, None)
+                    except Exception as e:
+                        print(f'doc_file: {doc_file}')
+                        print(f'row: {row}')
+                        traceback.print_exc()
+                        raise e
+
+    def _handle_head_middle_partition(
+            self, part, docs_files, qs_files, listings_ids
+    ):
+        assert len(docs_files) == len(qs_files)
+
+        listings_ids = listings_ids[:len(docs_files)]
+
+        for doc_file, qs_file, listings_id in zip(
+                docs_files, qs_files, listings_ids
+        ):
+            with gzip.open(doc_file, "rt", encoding="utf-8") as df:
+                with gzip.open(qs_file, "rt", encoding="utf-8") as qf:
+                    for row, (doc, qs) in enumerate(zip(df, qf)):
+                        doc_id = f"{listings_id}.json.gz/{row}"
+                        try:
+                            yield self.handle_record(part, doc_id, doc, qs)
+                        except Exception as e:
+                            print(f'doc_file: {doc_file}')
+                            print(f'qs_file: {qs_file}')
+                            print(f'row: {row}')
+                            traceback.print_exc()
+                            raise e
+
+    @staticmethod
+    def handle_record(part, doc_id, doc, qs):
+        doc = json.loads(doc)
+        qs = json.loads(qs) if qs is not None else {}
+
+        meta = {
+            "url": doc["url"],
+            "partition": part,
+            "language": doc["language"],
+            "source_domain": doc["source_domain"],
+            "date_download": doc["date_download"],
+            "digest": doc["digest"],
+        }
+
+        quality_signals = json.dumps(qs.get("quality_signals", {}))
+
+        return {
+            "raw_content": doc["raw_content"],
+            "doc_id": doc_id,
+            "meta": json.dumps(meta),
+            "quality_signals": quality_signals,
+        }