Create icy_dolma.py

icy_dolma.py

@@ -0,0 +1,220 @@
+"""IcyDolma dataset based on Common Crawl."""
+
+
+import gzip
+import json
+
+import datasets
+import more_itertools
+import numpy as np
+import io
+import json
+import dataclasses
+import pyzstd
+from tensorflow.io import gfile
+
+
+logger = datasets.logging.get_logger(__name__)
+
+
+_DESCRIPTION = """\
+"""
+
+_CITATION = """
+
+"""
+
+
+_VARIANTS = ["v3"]
+
+_DATA_URL = "gs://meliad2_us2/datasets/dolma/clustered_v3/train/shard_{}/subshard_{}/phase{}.jsonl"
+
+@dataclasses.dataclass
+class State:
+    file_index: int  
+    file_position: int  
+
+    def to_int(self) -> int:
+        return (self.file_position << 17) | self.file_index
+
+    @classmethod
+    def from_int(cls, value: int):
+        file_position = value >> 17
+        file_index = value & ((1 << 17) - 1)
+        return cls(file_index, file_position)
+    
+class ZstdReader:
+    def __init__(self,
+                 filepaths,
+                 worker_id,
+                 num_workers,
+                 file_loc=0,
+                 buffer_size=65536,
+                 deserialize_func=None,
+                 ):
+        self.filepaths = filepaths
+        n_shards = len(self.filepaths)
+        if n_shards == 0:
+            raise ValueError("No shards found")
+
+        logger.info(f"Found {len(self.filepaths)} files")
+        self.buffer_size = buffer_size
+        self.state = State.from_int(file_loc)
+        self.worker_id = worker_id
+        self.num_workers = num_workers
+        assert worker_id < num_workers, "worker_id must be less than num_workers"
+        if n_shards < num_workers:
+            self.workers_per_shard = num_workers // n_shards
+            self.filepaths = [self.filepaths[worker_id % n_shards]]
+            self.internal_worker_id = int(worker_id // n_shards)
+        else:
+            self.workers_per_shard = None
+            self.filepaths = list(more_itertools.distribute(num_workers, self.filepaths)[worker_id])
+        logger.info(f"Using {len(self.filepaths)} files")
+        
+        if deserialize_func is None:
+            self.deserialize_func = deserialize
+        else:
+            self.deserialize_func = deserialize_func
+
+        
+
+    def __iter__(self):
+        """This function returns the examples in the raw (text) form by iterating on all the files."""
+        while self.state.file_index<len(self.filepaths):
+            filepath = self.filepaths[self.state.file_index]
+            with gfile.GFile(filepath, 'rb') as f:
+                with pyzstd.ZstdFile(f, 'rb') as ifo:
+                    raw_reader = MultiBytesIOReader(ifo,
+                                                buffer_size=self.buffer_size,
+                                                file_position=self.state.file_position)
+                    if self.workers_per_shard is not None:
+                        reader = more_itertools.distribute(self.workers_per_shard, raw_reader)[self.internal_worker_id]
+                    else:
+                        reader = raw_reader
+                    for example in reader:
+                        self.state.file_position = raw_reader.tell()
+                        example = self.deserialize_func(example)
+                        example["file_loc"]  = self.state.to_int()
+                        yield  example
+            self.state.file_position = 0
+            self.state.file_index += 1
+        self.state = State.from_int(0)
+        
+
+
+
+def deserialize(data_point):
+    return json.loads(data_point.decode('utf-8'))
+
+class MultiBytesIOReader:
+    def __init__(self,
+                 decompressedStream: io.BytesIO,
+                 buffer_size=65536,
+                 file_position=0,
+                 ):
+        self.decompressedStream = decompressedStream
+        self.buffer_size = buffer_size
+        self.incomplete_line = bytearray()
+        self.position = file_position
+    
+    def seek(self, position):
+        self.position = position
+
+    def tell(self):
+        return self.position
+    
+    def __iter__(self):
+        self.decompressedStream.seek(self.position)
+        while True:
+            buffer = self.decompressedStream.read(self.buffer_size)
+            if not buffer:
+                break
+            buffer = self.incomplete_line + buffer
+            self.incomplete_line = bytearray()
+            lines = buffer.split(b'\n')
+            if lines and lines[-1]:
+                self.incomplete_line = lines.pop()
+            for line in lines:
+                if line:
+                    self.position += len(line)+1
+                    yield line
+        if self.incomplete_line:
+            self.position += len(self.incomplete_line)
+            yield self.incomplete_line
+
+
+class IcyDolmaConfig(datasets.BuilderConfig):
+    """BuilderConfig for IcyDolma."""
+
+    def __init__(self,
+                 name="v3",
+                 worker_id=None,
+                 n_workers=None,
+                 filepaths=None,
+                 file_loc=None,
+                 buffer_size=65536,
+                 **kwargs):
+        """BuilderConfig for IcyDolma.
+        Args:
+          **kwargs: keyword arguments forwarded to super.
+        """
+        super(IcyDolmaConfig, self).__init__(name=name,**kwargs)
+        self.worker_id = worker_id
+        self.n_workers = n_workers
+        self.filepaths = filepaths
+        self.file_loc = file_loc
+        self.buffer_size = buffer_size
+
+class IcyDolma(datasets.GeneratorBasedBuilder):
+    BUILDER_CONFIGS = [IcyDolmaConfig(name) for name in _VARIANTS]
+
+    def _info(self):
+        self.worker_id = self.config.worker_id
+        self.n_workers = self.config.n_workers
+        self.filepaths = self.config.filepaths
+        self.buffer_size = self.config.buffer_size
+        if self.config.filepaths is None:
+            self.filepaths = [_DATA_URL.format(i,j,k) for i in range(64) for j in range(64) for k in range(2)]
+        else:
+            self.filepaths = self.config.filepaths
+        if self.config.file_loc is not None:
+            self.file_loc = self.config.file_loc
+        else:
+            self.file_loc = 0
+        
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    "text": datasets.Value("string"),
+                    "source": datasets.Value("string"),
+                    "url": datasets.Value("string"),
+                    "id": datasets.Value("int32"),
+                    "file_loc": datasets.Value("int64"),
+                }
+            ),
+            supervised_keys=None,
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, _):
+        return [
+            datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={"filepaths": self.filepaths}),
+        ]
+
+    def _generate_examples(self, filepaths):
+        """This function returns the examples in the raw (text) form by iterating on all the files."""
+        id_ = 0
+        dataset = ZstdReader(filepaths=list(filepaths),
+                             worker_id=self.worker_id if self.worker_id is not None else 0,
+                             num_workers=self.n_workers if self.n_workers is not None else 1,
+                             file_loc=self.file_loc,
+                             buffer_size=self.buffer_size,
+                             )
+        for example in dataset:
+            url = example["id"]
+            example["id"] = id_
+            example["url"] = url
+            id_ += 1
+            yield id_, example