fix missing urls

RedPajama-Data-V2.py

@@ -19,7 +19,6 @@ import json
 
 import datasets
 import traceback
-import os
 import gzip
 from typing import List
 
@@ -33,7 +32,8 @@ 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")
-_LISTINGS_PATTERN = "listings/{language}-{snapshot}-{partition}.txt"
+_MISSING_FILES_PATTERN = "urls/missing-{component}.txt"
+_NUM_SHARDS = 5000
 
 _CC_SNAPSHOT_IDS = (
     "2014-15",
@@ -168,41 +168,39 @@ class RedPajamaV2(datasets.GeneratorBasedBuilder):
         )
 
     def _split_generators_sample(self, dl_manager):
-        # fetch documents
-        sample_listings = dl_manager.download_and_extract(
+        # fetch list of base tags
+        sample_base_tags_fp = dl_manager.download_and_extract(
             "sample/sample_listings.txt"
         )
-        with open(sample_listings, "r") as fd:
-            listings = [line.strip() for line in fd]
+        with open(sample_base_tags_fp, "r") as fd:
+            sample_base_tags = [line.strip() for line in fd]
 
         # fetch documents
+        logger.info(f"Downloading {len(sample_base_tags)} documents files.")
         documents_files = dl_manager.download({
-            "head_middle": [
-                f"sample/documents/{lst}.json.gz" for lst in listings
-            ]
+            base_tag: f"sample/documents/{base_tag}.json.gz"
+            for base_tag in sample_base_tags
         })
 
         # fetch quality signals
+        logger.info(f"Downloading {len(sample_base_tags)} quality signals files.")
         quality_signals_files = dl_manager.download({
-            "head_middle": [
-                f"sample/quality_signals/{lst}.signals.json.gz"
-                for lst in listings
-            ]
+            base_tag: f"sample/quality_signals/{base_tag}.signals.json.gz"
+            for base_tag in sample_base_tags
         })
 
         # fetch ids of duplicates
+        logger.info(f"Downloading {len(sample_base_tags)} duplicates ids files.")
         duplicates_ids_files = dl_manager.download({
-            "head_middle": [
-                f"sample/duplicates/{lst}.duplicates.parquet"
-                for lst in listings
-            ]
+            base_tag: f"sample/duplicates/{base_tag}.duplicates.parquet"
+            for base_tag in sample_base_tags
         })
 
         return [
             datasets.SplitGenerator(
                 name=datasets.Split.TRAIN,
                 gen_kwargs={
-                    "listings_ids": {"head_middle": listings},
+                    "base_tags": sample_base_tags,
                     "documents_files": documents_files,
                     "quality_signals_files": quality_signals_files,
                     "duplicates_ids_files": duplicates_ids_files
@@ -215,76 +213,72 @@ class RedPajamaV2(datasets.GeneratorBasedBuilder):
         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,
-                        )
-                    )
-
-        # fetch listings from hub
-        listings_files = dl_manager.download_and_extract(listings_files_urls)
-
-        # 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, quality signals and duplicate ids
-        document_urls = {}
-        quality_signals_urls = {}
-        duplicates_ids_urls = {}
-        for part, part_listings_ids in listings_ids.items():
-
-            document_urls[part] = []
-            quality_signals_urls[part] = []
-            duplicates_ids_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"
-                    )
-                )
+        if partition == 'all':
+            partitions = ['head', 'middle', 'tail']
+        elif partition == 'head_middle':
+            partitions = ['head', 'middle']
+        elif partition == 'tail':
+            partitions = [partition]
+        else:
+            raise ValueError(f'invalid partition: {partition}')
+
+        # fetch list of missing files (e.g., missing duplicates or corrupted documents and
+        # quality signal files)
+        missing_files_paths = dl_manager.download_and_extract({
+            component: _MISSING_FILES_PATTERN.format(component=component)
+            for component in ("documents", "signals", "duplicates")
+        })
 
-                duplicates_ids_urls[part].append(
-                    os.path.join(
-                        _URL_BASE, f"duplicates/{lst_id}.duplicates.parquet"
-                    )
-                )
+        missing_files = {}
+        for component, missing_file in missing_files_paths.items():
+            with open(missing_file) as f:
+                missing_files[component] = set(line.strip() for line in f)
 
-        documents_files = dl_manager.download(document_urls)
+        # build list of urls to fetch
+        documents_urls = {}
+        quality_signals_urls = {}
+        duplicates_ids_urls = {}
+        base_tags = []
+
+        for lang in languages:
+            for snapshot in snapshots:
+                for part in partitions:
+                    for n in range(_NUM_SHARDS):
+                        base_tag = f"{snapshot}/{n:04d}/{lang}_{part}"
+                        base_tags.append(base_tag)
+
+                        # documents
+                        url = f"{_URL_BASE}/documents/{base_tag}.json.gz"
+                        if url not in missing_files["documents"]:
+                            documents_urls[base_tag] = url
+
+                        # quality signals
+                        url = f"{_URL_BASE}/quality_signals/{base_tag}.signals.json.gz"
+                        if url not in missing_files["signals"]:
+                            quality_signals_urls[base_tag] = url
+
+                        # duplicates
+                        url = f"{_URL_BASE}/duplicates/{base_tag}.duplicates.parquet"
+                        if url not in missing_files["duplicates"]:
+                            duplicates_ids_urls[base_tag] = url
+
+        # download documents files
+        logger.info(f"Downloading {len(documents_urls)} documents files.")
+        documents_files = dl_manager.download(documents_urls)
+
+        # download quality signals files
+        logger.info(f"Downloading {len(quality_signals_urls)} quality signals files.")
         quality_signals_files = dl_manager.download(quality_signals_urls)
+
+        # download duplicates ids files
+        logger.info(f"Downloading {len(duplicates_ids_urls)} duplicates ids files.")
         duplicates_ids_files = dl_manager.download(duplicates_ids_urls)
 
         return [
             datasets.SplitGenerator(
                 name=datasets.Split.TRAIN,
                 gen_kwargs={
-                    "listings_ids": listings_ids,
+                    "base_tags": base_tags,
                     "documents_files": documents_files,
                     "quality_signals_files": quality_signals_files,
                     "duplicates_ids_files": duplicates_ids_files
@@ -299,91 +293,71 @@ class RedPajamaV2(datasets.GeneratorBasedBuilder):
         return self._split_generators_full(dl_manager)
 
     def _generate_examples(
-            self, listings_ids, documents_files, quality_signals_files,
+            self, base_tags, documents_files, quality_signals_files,
             duplicates_ids_files
     ):
         key = 0
-        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]
-            part_duplicates_ids_files = duplicates_ids_files[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 base_tag in base_tags:
+            doc_file = documents_files.get(base_tag)
+            qs_file = quality_signals_files.get(base_tag)
+            dupe_file = duplicates_ids_files.get(base_tag)
 
-            for sample in self._handle_head_middle_partition(
-                    part, part_docs_files, part_qs_files,
-                    part_duplicates_ids_files, part_listings_ids
+            if doc_file is None:
+                continue
 
+            for sample in self.__get_generator(
+                    base_tag, doc_file, qs_file, dupe_file
             ):
                 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}"
+    def __get_generator(self, base_tag, doc_file, qs_file, dupe_file):
+        if "_tail" in base_tag:
+            yield from self._handle_tail(base_tag, doc_file, qs_file, dupe_file)
+        else:
+            yield from self._handle_head_middle(base_tag, doc_file, qs_file, dupe_file)
+
+    def _handle_tail(self, base_tag, doc_file, qs_file, dupe_file):
+        with gzip.open(doc_file, "rt", encoding="utf-8") as df:
+            for row, doc in enumerate(df):
+                doc_id = f"{base_tag}.json.gz/{row}"
+                try:
+                    yield self.handle_record("tail", doc_id, doc, None, None)
+                except Exception as e:
+                    logger.warning(f'failed handling row {row} in {doc_file}')
+                    traceback.print_exc()
+                    continue
+
+    def _handle_head_middle(
+            self, base_tag, doc_file, qs_file, dupe_file
+    ):
+        if qs_file is None:
+            yield from self._handle_tail(base_tag, doc_file, None, None)
+            return
+
+        # load duplicates
+        try:
+            with open(dupe_file, "rb") as df:
+                duplicates = set(pq.read_table(
+                    df, columns=["doc_id"], use_pandas_metadata=False
+                )["doc_id"].to_pylist())
+        except Exception as e:
+            logger.warning(f'no duplicate ids found for {base_tag}')
+            duplicates = set()
+
+        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"{base_tag}.json.gz/{row}"
+
                     try:
-                        yield self.handle_record(part, doc_id, doc, None, None)
+                        yield self.handle_record(
+                            "head_middle", doc_id, doc, qs, is_duplicate=doc_id in duplicates
+                        )
                     except Exception as e:
-                        print(f'doc_file: {doc_file}')
-                        print(f'row: {row}')
+                        logger.warning(f'failed handling row {row} in {doc_file} ({qs_file})')
                         traceback.print_exc()
-                        raise e
-
-    def _handle_head_middle_partition(
-            self, part, docs_files, qs_files, dupes_files, listings_ids,
-    ):
-        assert len(docs_files) == len(qs_files)
-
-        listings_ids = listings_ids[:len(docs_files)]
-
-        for doc_file, qs_file, dupe_file, listings_id in zip(
-                docs_files, qs_files, dupes_files, listings_ids
-        ):
-            # load duplicates
-            try:
-                with open(dupe_file, "rb") as df:
-                    duplicates = set(pq.read_table(
-                        df, columns=["doc_id"], use_pandas_metadata=False
-                    )["doc_id"].to_pylist())
-            except Exception as e:
-                print(f'failed loading duplicate ids from {dupe_file}.')
-                duplicates = set()
-
-            try:
-                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}"
-
-                            if doc_id in duplicates:
-                                is_duplicate = True
-                            else:
-                                is_duplicate = False
-
-                            try:
-                                yield self.handle_record(
-                                    part, doc_id, doc, qs,
-                                    is_duplicate=is_duplicate
-                                )
-                            except Exception as e:
-                                print(f'failed handling row {row} in '
-                                      f'{doc_file} ({qs_file})')
-                                traceback.print_exc()
-                                continue
-            except gzip.BadGzipFile as e:
-                # skip broken gzip files
-                print(f'BadGzipFile: {doc_file, qs_file}')
-                traceback.print_exc()
-                continue
+                        continue
 
     @staticmethod
     def handle_record(part, doc_id, doc, qs, is_duplicate=None):