|
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(":", "|")) |
|
|
|
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)) |
|
|
|
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!") |
|
|
|
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='*.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) |
|
|
