Create dataset.py

dataset.py

@@ -0,0 +1,220 @@
+import torchdata.datapipes as dp
+import json
+from PIL import Image
+import functools
+import numpy as np
+import torch
+import pickle
+import random
+import os
+from braceexpand import braceexpand
+from torch.utils.data.datapipes.iter.sharding import SHARDING_PRIORITIES
+from torch.utils.data.dataloader import default_collate
+import base64
+import io
+import tarfile
+from torchdata.datapipes.iter import TarArchiveLoader
+from typing import cast, IO, Iterable, Iterator, Optional, Tuple, Dict
+from torchdata.datapipes import functional_datapipe
+from io import BufferedIOBase
+from torchdata.datapipes.utils import StreamWrapper
+from torchdata.datapipes.utils.common import validate_pathname_binary_tuple
+import warnings
+from torchdata.datapipes.iter import IterDataPipe
+import hydra
+from omegaconf import OmegaConf
+import pyrootutils
+
+pyrootutils.setup_root(__file__, indicator='.project-root', pythonpath=True)
+
+BOI_TOKEN = '<img>'
+EOI_TOKEN = '</img>'
+IMG_TOKEN = '<img_{:05d}>'
+
+
+@functional_datapipe("load_from_tar_wo_exception")
+class TarArchiveLoaderWoException(TarArchiveLoader):
+    def __iter__(self) -> Iterator[Tuple[str, BufferedIOBase]]:
+        for data in self.datapipe:
+            validate_pathname_binary_tuple(data)
+            pathname, data_stream = data
+            try:
+                if isinstance(data_stream, StreamWrapper) and isinstance(data_stream.file_obj, tarfile.TarFile):
+                    tar = data_stream.file_obj
+                else:
+                    reading_mode = (self.mode if hasattr(data_stream, "seekable") and data_stream.seekable() else
+                                    self.mode.replace(":", "|"))
+                    # typing.cast is used here to silence mypy's type checker
+                    tar = tarfile.open(fileobj=cast(
+                        Optional[IO[bytes]], data_stream), mode=reading_mode)
+                for tarinfo in tar:
+                    if not tarinfo.isfile():
+                        continue
+                    extracted_fobj = tar.extractfile(tarinfo)
+                    if extracted_fobj is None:
+                        warnings.warn(
+                            f"failed to extract file {tarinfo.name} from source tarfile {pathname}")
+                        raise tarfile.ExtractError
+                    inner_pathname = os.path.normpath(
+                        os.path.join(pathname, tarinfo.name))
+                    # type: ignore[misc]
+                    yield inner_pathname, StreamWrapper(extracted_fobj, data_stream, name=inner_pathname)
+            except Exception as e:
+                warnings.warn(
+                    f"Unable to extract files from corrupted tarfile stream {pathname} due to: {e}, abort!")
+                # raise e
+            finally:
+                if isinstance(data_stream, StreamWrapper):
+                    data_stream.autoclose()
+
+
+def decode_obelisc_data_for_llm(item, tokenizer=None, max_length=512, reverse_ratio=0.5, max_images=None):
+    key, value = item
+
+    sample = {}
+    if key.endswith(".pkl"):
+        try:
+            value = pickle.load(value)
+        except Exception as e:
+            print(f'Error occured when load pkl: {e}')
+            return key, sample
+
+        image_list = value['image_ids']
+        text_list = value['texts']
+        metadata = value['metadata']
+
+        reverse_flag = np.random.uniform(0, 1) < reverse_ratio
+        if reverse_flag:
+            idx = 0
+            while idx < len(image_list) - 1:
+                if image_list[idx] is not None:
+                    image_list[idx], image_list[idx +
+                                                1] = image_list[idx + 1], image_list[idx]
+                    text_list[idx], text_list[idx +
+                                              1] = text_list[idx + 1], text_list[idx]
+                    idx += 2
+                else:
+                    idx += 1
+
+        unified_tokens = tokenizer.bos_token
+        cur_images = 0
+        for image_id, text in zip(image_list, text_list):
+            if (image_id is None) + (text is None) != 1:
+                print('Incorrect data format, skip.')
+                return key, {}
+            if image_id is not None:
+                if max_images is not None and cur_images >= max_images:
+                    break
+                image_tokens = BOI_TOKEN + \
+                    ''.join([IMG_TOKEN.format(int(item))
+                            for item in image_id]) + EOI_TOKEN
+                unified_tokens += image_tokens
+                cur_images += 1
+            else:
+                unified_tokens += text
+                if max_images is not None and cur_images >= max_images:
+                    break
+        unified_tokens += tokenizer.eos_token
+
+        tokenized = tokenizer(unified_tokens,
+                              max_length=max_length,
+                              add_special_tokens=False,
+                              truncation=True,
+                              padding='max_length',
+                              return_tensors='pt')
+
+        input_ids = tokenized['input_ids'][0]
+        attention_mask = tokenized['attention_mask'][0]
+        labels = torch.clone(input_ids)
+        labels[labels == tokenizer.pad_token_id] = -100
+        filter_flag = True
+
+        return key, {
+            'input_ids': input_ids,
+            'attention_mask': attention_mask,
+            'labels': labels,
+            'filter_flag': filter_flag,
+        }
+    else:
+        return key, None
+
+
+def unwarp_data(item):
+    unwarpped = {}
+    for key, value in item.items():
+        if isinstance(value, dict):
+            unwarpped.update(value)
+        elif value is not None:
+            unwarpped[key] = value
+    if 'metadata' not in unwarpped:
+        unwarpped['metadata'] = '{}'
+    if '__key__' in unwarpped:
+        unwarpped['__key__'] = unwarpped['__key__'].split('/')[-1]
+    return unwarpped
+
+
+def filter_data_for_llm(item):
+    if 'input_ids' in item and item.get('filter_flag', True):
+        return True
+    else:
+        print('A sample has been filtered out.')
+        return False
+
+
+def build_obelisc_datapipes_for_llm(data_dir,
+                                    tokenizer=None,
+                                    max_length=512,
+                                    reverse_ratio=0.5,
+                                    max_images=None,
+                                    recursive=True,
+                                    batch_size=None,
+                                    cycle_count=None):
+    """
+    datapipe of image interleaved dataset (such as mmc4...) with webdataset format
+    """
+
+    decode_partial = functools.partial(decode_obelisc_data_for_llm,
+                                       tokenizer=tokenizer,
+                                       max_length=max_length,
+                                       reverse_ratio=reverse_ratio,
+                                       max_images=max_images)
+
+    if isinstance(data_dir, str):
+        data_dir = list(braceexpand(data_dir))
+    # datapipe = dp.iter.FileLister(root=data_dir, masks='mmc4-0-000004.tar', recursive=True)
+    datapipe = dp.iter.FileLister(
+        root=data_dir, masks='*.tar', recursive=recursive)
+    datapipe = datapipe.cycle(count=cycle_count)
+    datapipe = datapipe.shuffle()
+    datapipe = datapipe.sharding_filter()
+    datapipe = datapipe.open_files(mode='b')
+    datapipe = datapipe.load_from_tar_wo_exception()
+    datapipe = datapipe.map(decode_partial)
+    datapipe = datapipe.webdataset()
+    datapipe = datapipe.map(unwarp_data)
+    datapipe = datapipe.filter(filter_data_for_llm)
+    datapipe = datapipe.shuffle(buffer_size=4096)
+    if batch_size is not None:
+        datapipe = datapipe.batch(batch_size)
+        datapipe = datapipe.collate()
+    return datapipe
+
+
+if __name__ == '__main__':
+    from torchdata.dataloader2 import DataLoader2, MultiProcessingReadingService, DistributedReadingService, SequentialReadingService
+    data_dir = './obelisc'
+    seed_tokenizer_cfg_path = ''
+    dataloader_num_workers = 2
+
+    seed_tokenizer_cfg = OmegaConf.load(seed_tokenizer_cfg_path)
+    seed_tokenizer = hydra.utils.instantiate(seed_tokenizer_cfg)
+
+    dataset = build_obelisc_datapipes_for_llm(
+        data_dir=data_dir, tokenizer=seed_tokenizer, max_length=1024, cycle_count=1)
+
+    mp_rs = MultiProcessingReadingService(
+        num_workers=dataloader_num_workers)
+    dist_rs = DistributedReadingService()
+    rs = SequentialReadingService(dist_rs, mp_rs)
+
+    dataloader = DataLoader2(dataset, reading_service=rs)