| """Zstd 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__) |
|
|
|
|
| @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 ZstdConfig(datasets.BuilderConfig): |
| """BuilderConfig for Zstd.""" |
|
|
| def __init__(self, |
| data_url=None, |
| cluster_layout=None, |
| worker_id=None, |
| n_workers=None, |
| filepaths=None, |
| file_loc=None, |
| buffer_size=65536, |
| cluster_spec=None, |
| features=None, |
| **kwargs): |
| """BuilderConfig for Zstd. |
| Args: |
| **kwargs: keyword arguments forwarded to super. |
| """ |
| super(ZstdConfig, self).__init__(**kwargs) |
| self.cluster_layout = cluster_layout |
| self.data_url = data_url |
| self.worker_id = worker_id |
| self.n_workers = n_workers |
| self.filepaths = filepaths |
| self.file_loc = file_loc |
| self.buffer_size = buffer_size |
| self.cluster_spec = cluster_spec |
| self.features = features |
| assert (self.cluster_spec is None) or (self.filepaths is None ) |
|
|
|
|
|
|
|
|
| import numpy as np |
| import itertools |
| def get_cluster_tuples(cluster_layout, cluster_spec): |
| if cluster_spec is None: |
| cluster_spec = (None,)*len(cluster_layout) |
| |
| cluster_spec = cluster_spec + (None,)*(len(cluster_layout)-len(cluster_spec)) |
| dim_list = [] |
| for a,b in zip(cluster_layout,cluster_spec): |
| if b is None: |
| dim_list.append(range(a)) |
| else: |
| dim_list.append([b]) |
| |
| return list(itertools.product(*dim_list)) |
|
|
| def _get_filepaths(config): |
| cluster_layout = config.cluster_layout[config.name] |
| cluster_spec = config.cluster_spec |
| if config.filepaths is not None: |
| filepaths = config.filepaths |
| else: |
| tuples = get_cluster_tuples(cluster_layout, cluster_spec) |
| filepaths = [config.data_url[config.name].format(*tup) for tup in tuples] |
| return filepaths |
| |
|
|
| class Zstd(datasets.GeneratorBasedBuilder): |
| BUILDER_CONFIGS = [ZstdConfig()] |
|
|
| def _info(self): |
| self.data_url = self.config.data_url |
| self.cluster_layout = self.config.cluster_layout |
| assert self.cluster_layout is not None |
| assert self.data_url is not None |
| self.worker_id = self.config.worker_id |
| self.n_workers = self.config.n_workers |
| self.buffer_size = self.config.buffer_size |
| self.filepaths = _get_filepaths(self.config) |
| if self.config.features is None: |
| self.features=datasets.Features( |
| { |
| "text": datasets.Value("string"), |
| "source": datasets.Value("string"), |
| "url": datasets.Value("string"), |
| "id": datasets.Value("int32"), |
| "file_loc": datasets.Value("int64"), |
| } |
| ) |
| else: |
| self.features = self.config.features |
| |
| if self.config.file_loc is not None: |
| self.file_loc = self.config.file_loc |
| else: |
| self.file_loc = 0 |
| |
| return datasets.DatasetInfo( |
| features=self.features, |
| supervised_keys=None, |
| ) |
|
|
| 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 |
| if id_==0: |
| print(f"{example.keys()=}") |
| id_ += 1 |
| yield id_, example |
