Add files using upload-large-folder tool

dataset_code/sft_sftnews/offload/dataset_tool/AIP_dataset.py

@@ -0,0 +1,309 @@
+import torch
+from torch.utils.data.dataset import Dataset
+from torchvision.transforms.functional import to_tensor
+from nebudata import refds
+from .parquet_dataset.utils import hdfs_utils
+from .parquet_dataset.parquet_utils import get_random_for_rank_and_worker, get_portion_for_rank_and_worker, get_worker_id, get_worker_count
+from .parquet_dataset.utils.distributed_utils import get_data_parallel_rank, get_data_parallel_world_size
+import random
+from PIL import Image
+import copy
+import numpy as np
+import json
+from multiprocessing import Pool
+import traceback
+
+
+try:
+    import av
+    import io
+    pyav_enabled = True
+except:
+    pyav_enabled = False
+
+try:
+    import imageio.v3 as iio
+    imageio_enabled = True
+except:
+    imageio_enabled = False
+
+
+def get_length(path, ignore_prefixes):
+    dataset = refds.RefDataset(
+        path, ignore_prefixes=ignore_prefixes)
+    return dataset.rank_total
+
+
+def get_length_subprocess(path, ignore_prefixes):
+    with Pool(1) as pool:
+        counts = pool.apply(
+            get_length, args=(path, ignore_prefixes, ))
+    return counts
+
+
+def sampling(video_length, sample_n_frames, sample_stride, skip_start_end=10):
+    # Jacob Sep 17th: If sample frames > video frames, we drop this video
+    if (sample_n_frames - 1) * sample_stride + 1 > (video_length - skip_start_end * 2):
+        return None
+    clip_length = min(
+        video_length, (sample_n_frames - 1) * sample_stride + 1)
+    start_idx = random.randint(
+        skip_start_end, video_length - clip_length - skip_start_end)
+    batch_index = np.linspace(
+        start_idx, start_idx + clip_length - 1, sample_n_frames, dtype=int)
+    return batch_index
+
+
+class AIPVideoDataset(Dataset):
+    def __init__(self,
+                 path,
+                 sample_size=256,
+                 sample_stride=4,
+                 sample_n_frames=16,
+                 caption_key='caption',
+                 caption_path="",
+                 fps=24,
+                 shuffle=True,
+                 infinite=True,
+                 parquet_batch=128,
+                 video_toskey='clip_toskey',
+                 bytes_key='bytes',
+                 ignore_prefixes=None,
+                 decode_backend='pyav',
+                 force_partition=False,
+                 data_world_size=10000, # TODO: can be dynamic
+                 local_cache_prefix='',
+                 ):
+        self.sample_size = sample_size
+        assert self.sample_size == -1, \
+            "only support original size, consider using sample_size==-1 for bucketing"
+        self.sample_stride = sample_stride
+        self.sample_n_frames = sample_n_frames
+        self.shuffle = shuffle
+        self.infinite = infinite # this doesn't work, the dataset is always infinite
+        self.fps = fps
+        self.force_partition = force_partition
+        self.data_world_size = data_world_size
+        self.state_dict = {'data_world_size': self.data_world_size, 'seen_times': [0 for _ in range(self.data_world_size)]}
+        self.remaining_ranks = []
+        self.local_cache_prefix = local_cache_prefix
+
+        self.path = path
+        self.parquet_batch = parquet_batch
+        self.video_toskey = video_toskey
+        self.caption_key = caption_key  # the key used to store caption
+        self.bytes_key = bytes_key  # the key used to store real bytes
+        self.ignore_prefixes = ignore_prefixes
+        self.decode_backend = decode_backend
+
+        self.total_length = None
+        # read caption json file from caption_path seperately, for Seed V2 dataset
+        self.caption_data = None
+        if caption_path != "":
+            # with open(caption_path, 'r') as f:
+            if caption_path.startswith("hdfs"):
+                caption_path = hdfs_utils.download(caption_path, './')
+            with open(caption_path, 'r') as f:
+                caption_data = json.load(f)
+            caption_data = json.loads(hdfs_utils.read(caption_path))
+            self.total_length = len(caption_data)
+            self.caption_data = {item['uttid']: item[self.caption_key]
+                                 for item in caption_data}
+
+        if self.decode_backend == 'imageio':
+            assert imageio_enabled, 'failed to install imageio'
+        elif self.decode_backend == 'pyav':
+            assert pyav_enabled, 'failed to install pyav'
+
+    def __iter__(self):
+        rank = get_data_parallel_rank()
+        world_size = get_data_parallel_world_size()
+        worker_id = get_worker_id()
+        worker_count = get_worker_count()
+        overall_workers = world_size * worker_count
+
+        self.local_cache_path = f'{self.local_cache_prefix}_{rank}_{worker_id}.txt'
+        refs = [(self.video_toskey, self.bytes_key)
+                ] if self.video_toskey != '' else []
+
+        worker_ranks = get_portion_for_rank_and_worker(self.remaining_ranks, allow_empty=True)
+
+        while True:
+            if self.shuffle:
+                get_random_for_rank_and_worker(None).shuffle(worker_ranks)
+
+            for rank in worker_ranks:
+                with open(self.local_cache_path, 'a') as f:
+                    f.write(f'{rank}\n')
+                filereader = refds.RefDataset(self.path, ignore_prefixes=self.ignore_prefixes, world_size=self.data_world_size, rank=rank)
+                for batch in filereader.iter_batches(batch_size=self.parquet_batch, refs=refs):
+                    actual_size = len(batch[self.bytes_key])
+                    columns = [col for col in batch.column_names]
+                    for i in range(actual_size):
+                        params_dict = {col: batch[col]
+                                       [i].as_py() for col in columns}
+                        if self.caption_data is not None:
+                            # if we have caption_data, use it to replace caption
+                            uttid = params_dict['uttid']
+                            if uttid not in self.caption_data:
+                                continue
+                            params_dict[self.caption_key] = self.caption_data[uttid]
+                        frames, metadata = self._data_process(params_dict)
+                        if frames is None:
+                            continue
+                        yield self._pack_frames(frames, metadata)
+
+            overall_ranks = []
+            while len(overall_ranks) < overall_workers:
+                overall_ranks += list(range(self.data_world_size))
+            worker_ranks = get_portion_for_rank_and_worker(overall_ranks, force=True)
+
+    def _pack_frames(self, frames, metadata):
+        tensor_frames = []
+        for frame in frames:
+            frame = to_tensor(frame)
+            tensor_frames.append(frame)
+        tensor_frames = torch.stack(tensor_frames)
+        # make value from -1.0 to 1.0
+        pixel_values = tensor_frames * 2.0 - 1.0
+        item = dict(
+            mp4=pixel_values,
+            txt=metadata[self.caption_key],
+            num_frames=self.sample_n_frames,
+            fps=metadata.get('fps', self.fps),
+        )
+        return item
+
+    def _data_process(self, params):
+        tosbytes = params[self.bytes_key]
+        del params[self.bytes_key]  # remove the bytes key
+        metadata = copy.deepcopy(params)
+        try:
+            frames = self._bytes_to_PILs(tosbytes)
+        except:
+            print("data error: ", metadata)
+            traceback.print_exc()
+            return None, None
+        if frames is None:
+            return None, None
+        return frames, metadata
+
+    def _bytes_to_PILs(self, video_bytes):
+        if self.decode_backend == 'imageio':
+            raw_frames = iio.imread(
+                video_bytes, index=None, format_hint=".mp4")
+            video_length = raw_frames.shape[0]
+            video_idxs = sampling(
+                video_length, self.sample_n_frames, self.sample_stride)
+            if video_idxs is None:
+                return None
+            frames = []
+            for i in video_idxs:
+                frames.append(Image.fromarray(raw_frames[i], 'RGB'))
+
+        elif self.decode_backend[:4] == 'pyav':
+            file_io = io.BytesIO(video_bytes)
+            container = av.open(file_io)
+            stream = container.streams.video[0]
+            video_length = container.streams.video[0].frames
+            video_idxs = sampling(
+                video_length, self.sample_n_frames, self.sample_stride)
+            if video_idxs is None:
+                return None
+            frames_sorted = []
+            key_frame_idxs = []
+
+            # Get keyframe without decoding
+            stream.codec_context.skip_frame = "NONKEY"
+            for packet in container.demux(stream):
+                if packet.is_keyframe:
+                    frame_idx = int(
+                        packet.pts * stream.time_base * stream.average_rate + 1e-6)
+                    key_frame_idxs.append(frame_idx)
+
+            # Reset for decode any frames
+            stream.codec_context.skip_frame = "DEFAULT"
+
+            # Sort the frames under the cases that frames are unsorted
+            video_idxs_sort_idx = np.argsort(np.array(video_idxs))
+            video_idxs_sorted = np.array(video_idxs)[video_idxs_sort_idx]
+
+            # The keyframe assignment for each frame
+            keyframe_assignment = np.clip(((np.array(video_idxs_sorted)[
+                                          None] - np.array(key_frame_idxs)[:, None]) > 0).sum(0) - 1, 0, None)
+
+            time_base = container.streams.video[0].time_base
+            framerate = container.streams.video[0].average_rate
+
+            previous_keyframe_assigment = -1
+            for ii, frame_num in enumerate(video_idxs_sorted):
+                this_assignment = keyframe_assignment[ii]
+
+                # Reseek only if when the keyframe are changed, avoid redecode frames
+                if this_assignment != previous_keyframe_assigment:
+                    # Calculate the timestamp for the desired frame
+                    frame_container_pts = int(
+                        ((key_frame_idxs[this_assignment] + 1) / framerate) / time_base)
+
+                    # Seek to the closest keyframe before the desired timestamp
+                    container.seek(frame_container_pts, backward=True,
+                                   stream=container.streams.video[0])
+                    previous_keyframe_assigment = this_assignment
+
+                    # Record where we start, for debug only
+                    # start_idx = key_frame_idxs[this_assignment]
+
+                previous_frame_idx = -1
+                while previous_frame_idx < frame_num:
+                    frame = next(container.decode(video=0))
+                    previous_frame_idx = int(
+                        frame.pts * stream.time_base * stream.average_rate + 1e-6)
+                # Debug code to check if always get the desired frame
+                # print(f"start={start_idx}, source={previous_frame_idx}, target={frame_num}, ")
+                frames_sorted.append(frame.to_image())
+
+            # Recollect to the original sorts => inverse sort
+            frames = [None for _ in range(len(video_idxs))]
+            for i, idx in enumerate(video_idxs_sort_idx):
+                frames[idx] = frames_sorted[i]
+        elif self.decode_backend == 'image_bytes':
+            video_length = len(video_bytes)
+            video_idxs = sampling(
+                video_length, self.sample_n_frames, self.sample_stride)
+            if video_idxs is None:
+                return None
+            frames = []
+            for idx in video_idxs:
+                frame_byte = video_bytes[idx]
+                with Image.open(io.BytesIO(frame_byte)) as frame:
+                    frame = frame.convert("RGB")
+                frames.append(frame)
+
+        return frames
+
+    def load_state_dict(self, state_dict):
+        # get remaining ranks
+        if 'data_world_size' not in self.state_dict:
+            print('[AIP_dataset] no state_dict; init data loading')
+        elif self.data_world_size != self.state_dict['data_world_size']:
+            print('[AIP_dataset] inconsistent data_world_size, init data loading')
+        elif self.state_dict['data_world_size'] != len(self.state_dict.get('seen_times', [])):
+            print('[AIP_dataset] corrupted state_dict; init data loading')
+        else:
+            #this has to be the same across all workers
+            self.state_dict = state_dict
+            print('[AIP_dataset] resume data loading from state_dict')
+            max_times = max(self.state_dict['seen_times'])
+            for rank, times in enumerate(self.state_dict['seen_times']):
+                for _ in range(max_times-times):
+                    self.remaining_ranks.append(rank)
+
+    def __len__(self):
+        if self.total_length is None:
+            counts = get_length_subprocess(self.path, self.ignore_prefixes)
+            self.total_length = counts
+        return self.total_length
+
+    @ classmethod
+    def create_dataset_function(cls, data_path, args, **kwargs):
+        return cls(path=data_path, **kwargs)

dataset_code/sft_sftnews/offload/dataset_tool/__init__.py

@@ -0,0 +1,5 @@
+from .dataset_hdfs import *
+from .image_dataset import T2IHDFSDataset, T2IHDFSDataset_dump
+from .parquet_dataset.video_parquet import SeedV1Dataset, SeedV1Dataset_dump
+from .AIP_dataset import AIPVideoDataset
+from .collection_dataset import CollectionDataset, CollectionDataset_dump, collate_fn_map

dataset_code/sft_sftnews/offload/dataset_tool/collection_dataset.py

@@ -0,0 +1,672 @@
+import io
+import os
+import json
+import glob
+import torch
+from copy import deepcopy
+from typing import Dict, List
+import importlib
+import random
+from torch.utils.data import ChainDataset, IterableDataset, Dataset
+import torchvision.transforms as transforms
+from torch.utils.data._utils.collate import default_collate
+from torchvision.transforms import functional as F
+import concurrent.futures
+
+from dataset_tool.AIP_dataset import AIPVideoDataset
+
+from PIL import Image
+from diffusers.utils import export_to_video
+from diffusers.training_utils import free_memory
+
+def collate_fn_map(samples):
+    """
+    Custom collate function that processes a list of samples into a batch.
+    """
+    if type(samples) is list and type(samples[0]) is list:
+        samples = samples[0]  # remove the first batch, as it is always 1
+        if isinstance(samples[0], dict):
+            none_keys = []
+            for key in samples[0]:
+                values = [sample[key] for sample in samples]
+                if any(value is None for value in values):
+                    none_keys.append(key)
+
+            if none_keys:
+                print(f"Warning: Found None values in keys: {none_keys}")
+                
+            return {key: default_collate([sample[key] for sample in samples]) for key in samples[0]}
+        raise NotImplementedError
+    else:
+        return default_collate(samples)
+
+
+class CollectionDataset_dump(IterableDataset):
+    def __init__(
+        self,
+        train_data: list[str],
+        train_data_weights: list[int | float],
+        dataset_collections: Dict[str, Dict],
+        batch_size=1,
+        image_batch_size=48,
+        enable_bucket=False,
+        infinite=True,
+        shuffle=True,
+        local_cache='', # this should be a ByteNAS path
+        data_cache_prefix={'AIPVideoDataset': 'aip_dataset_cache'},
+    ):
+        # prepare for bucketings
+        self.enable_bucket = enable_bucket
+        self.batch_size = batch_size
+        self.image_batch_size = image_batch_size
+
+        self.buckets = {}
+        self.buckets_transform = {}
+        self.resolutions = set()
+        if not self.enable_bucket:
+            assert batch_size == 1, "if not enable_bucket, batch_size must be 1"
+
+        self.train_data_weights = train_data_weights
+
+        self.dataset_list = []
+        self.dataset_names = []
+        self.image_dataset_names = []
+        self.dataset_collections = dataset_collections
+        self.dataset_to_aspect_ratios = {}
+        self.init_state_dict = {}
+        self.local_cache_prefix_list = []
+        for data_name in train_data:
+            if data_name not in dataset_collections:
+                print(f'{data_name} not in dataset collections')
+                return
+            self.dataset_config = dataset_collections[data_name]
+            aspect_ratios = self.dataset_config['aspect_ratios']
+            self.dataset_to_aspect_ratios[data_name] = aspect_ratios
+            self.add_aspect_ratios(aspect_ratios)
+
+            module, cls = self.dataset_config['target'].rsplit(".", 1)
+            data_class = getattr(
+                importlib.import_module(module, package=None), cls)
+            if cls == 'T2IHDFSDataset' or cls == 'T2IHDFSDataset_dump':
+                self.image_dataset_names.append(data_name)
+
+            if cls in data_cache_prefix:
+                data_cache = os.path.join(local_cache, data_cache_prefix[cls])
+                os.makedirs(data_cache, exist_ok=True)
+                local_cache_prefix = os.path.join(data_cache, data_name)
+                self.clean_cache(local_cache_prefix)
+                self.dataset_config['params']['local_cache_prefix'] = local_cache_prefix
+                self.local_cache_prefix_list.append(local_cache_prefix)
+            else:
+                self.local_cache_prefix_list.append('')
+            dataset = data_class.create_dataset_function(
+                self.dataset_config['path'], None, **self.dataset_config['params'])
+            if cls == 'AIPVideoDataset':
+                self.init_state_dict[data_name] = dataset.state_dict
+            self.dataset_list.append(dataset)
+            self.dataset_names.append(data_name)
+        self.length = sum([len(dataset) for dataset in self.dataset_list])
+        self.dataset_iter_list = [iter(dataset) for dataset in self.dataset_list]
+
+    def add_aspect_ratios(self, aspect_ratios):
+        for key in aspect_ratios.keys():
+            self.buckets[key] = []
+
+        for key, sample_size in aspect_ratios.items():
+            sample_size = tuple(sample_size)
+            self.buckets_transform[key] = transforms.Compose([
+                transforms.Resize(min(sample_size[0], sample_size[1])), # fix when height > width
+                transforms.CenterCrop(sample_size),
+            ])
+        for h, w in aspect_ratios.values():
+            self.resolutions.add((49, h, w))
+
+    def get_bucket_id(self, item, dataset_name):
+        """
+        for large resolution data, we may have multiple bucket ids
+        """
+        _,_,_,H,W = item['mp4']['latent_256_size']
+        H = H * 64
+        W = W* 64
+        ratio = float(H) / float(W)
+
+        ratio_strategy = self.dataset_collections[dataset_name]['ratio_strategy']
+        ratios = self.dataset_to_aspect_ratios[dataset_name]
+        if ratio_strategy == 'random':
+            bucket_id = random.choice(list(ratios.keys()))
+        elif ratio_strategy == 'closest':
+            bucket_id = min(ratios.items(),
+                            key=lambda r: abs(float(r[1][0]) / float(r[1][1]) - ratio))[0]
+        else:
+            raise f"ratio_strategy {ratio_strategy} not support ..."
+
+        return bucket_id
+
+    def __len__(self):
+        return self.length
+
+    def crop_and_resize(self, image, h_prime, w_prime):
+        """
+        Crop and resize a 4D tensor image.
+
+        Args:
+            image: The input 4D tensor image of shape (frame, channel, h, w).
+            h_prime: Desired height of the cropped image.
+            w_prime: Desired width of the cropped image.
+
+        Returns:
+            The cropped and resized 4D tensor image.
+        """
+        frames, channels, h, w = image.shape
+        aspect_ratio_original = h / w
+        aspect_ratio_target = h_prime / w_prime
+
+        if aspect_ratio_original >= aspect_ratio_target:
+            new_h = int(w * aspect_ratio_target)
+            top = (h - new_h) // 2
+            bottom = top + new_h
+            left = 0
+            right = w
+        else:
+            new_w = int(h / aspect_ratio_target)
+            left = (w - new_w) // 2
+            right = left + new_w
+            top = 0
+            bottom = h
+        # print(f"left {left}, right {right}, top {top}, bottom {bottom}")
+        # Crop the image
+        cropped_image = image[:, :, top:bottom, left:right]
+        # Resize the cropped image
+        resized_image = F.resize(cropped_image, (h_prime, w_prime))
+        return resized_image
+
+    def put_to_bucket(self, item, dataset_name):
+        if len(item['latent'].shape) == 5:
+            _,_,_,H,W = item['latent'].shape
+        else:
+            _,_,H,W = item['latent'].shape
+        bucket_id = []
+        for key, value in self.dataset_to_aspect_ratios[dataset_name].items():
+            if value == [H * 64, W* 64]:
+                bucket_id = key
+        ori_frams, ori_c, ori_H, ori_W = item['mp4'].shape
+        ori_ratio = ori_H / ori_W
+        bucket_h, bucket_w = self.dataset_to_aspect_ratios[dataset_name][bucket_id][0], self.dataset_to_aspect_ratios[dataset_name][bucket_id][1]
+        bucket_ratio = bucket_h / bucket_w
+        # print(f"ori_H {ori_H}, ori_W {ori_W}, ori_ratio {ori_ratio}. bucket_h {bucket_h}, bucket_w {bucket_w}, bucket_ratio {bucket_ratio}")
+        item['mp4'] = self.crop_and_resize(item['mp4'], bucket_h, bucket_w)
+
+        # ori_frams, ori_c, ori_H, ori_W = item['mp4'].shape
+        # ori_ratio = ori_H / ori_W
+        # bucket_h, bucket_w = self.dataset_to_aspect_ratios[dataset_name][bucket_id][0], self.dataset_to_aspect_ratios[dataset_name][bucket_id][1]
+        # bucket_ratio = bucket_h / bucket_w
+        # # print(f"ori_H {ori_H}, ori_W {ori_W}, ori_ratio {ori_ratio}. bucket_h {bucket_h}, bucket_w {bucket_w}, bucket_ratio {bucket_ratio}")
+        # item['mp4'] = self.crop_and_resize(item['mp4'], bucket_h, bucket_w)
+
+        # frames, c, H, W = item['mp4'].shape
+        # # rewrite item to the same format as the original dataset
+        new_item = {}
+        new_item['videos'] = item['mp4']
+        if len(item['latent'].shape) == 5:
+            new_item['latent'] = item['latent'][0]
+        else:
+            new_item['latent'] = item['latent']
+        new_item['prompts'] = item['txt'] if item['txt'] is not None else "" # check text
+        latent_tail = item.get('latent_tail')
+        if latent_tail is not None:
+            new_item['latent_tail'] = item['latent_tail']
+        latent_flow = item.get('latent_flow')
+        if latent_flow is not None:
+            new_item['latent_flow'] = item['latent_flow']
+        # else:
+        #     new_item['latent_tail'] = None
+        # new_item['video_metadata'] = {
+        #     'num_frames': frames,
+        #     'height': H,
+        #     'width': W,
+        # }
+        self.buckets[bucket_id].append(new_item)
+
+        batch = None
+        cur_batch_size = self.image_batch_size if bucket_id.startswith("i-") else self.batch_size
+        if len(self.buckets[bucket_id]) >= cur_batch_size:
+            batch = self.buckets[bucket_id]
+            self.buckets[bucket_id] = []
+        return batch
+
+    def __iter__(self):
+        def __native__iter():
+            while True:
+                dataset_idx = random.choices(
+                    list(range(len(self.dataset_list))), weights=self.dataset_weights)[0]
+                dataset = self.dataset_iter_list[dataset_idx]
+                yield next(dataset)
+
+        def __bucket__iter():
+            def get_next_item(dataset):
+                return next(dataset)
+            while True:
+                dataset_idx = random.choices(
+                    list(range(len(self.dataset_list))), weights=self.train_data_weights)[0]
+                dataset = self.dataset_iter_list[dataset_idx]
+                dataset_name = self.dataset_names[dataset_idx]
+                if dataset_name in self.image_dataset_names:
+                    replicate_times = max(int(self.image_batch_size / self.batch_size), 1)
+                    batch_data_list = []
+                    while replicate_times > 0:
+                        item = next(dataset)
+                        batch_data = self.put_to_bucket(item, dataset_name)
+                        if batch_data is not None:
+                            batch_data_list.append(batch_data)
+                        replicate_times -= 1
+                    for batch_data in batch_data_list:
+                        yield batch_data
+                # else:
+                #     item = next(dataset)
+                #     if item == "wtf_is_abnormal":
+                #         print(f"too much abnormal from {dataset_name}, continue")
+                #         continue
+                #     if item == "max_bad_file_count_reached":
+                #         print(f"{dataset_name} for this worker is corrupted, continue")
+                #         continue
+                #     batch_data = self.put_to_bucket(item, dataset_name)
+                #     if batch_data is not None:
+                #         yield batch_data
+                else:
+                    with concurrent.futures.ThreadPoolExecutor() as executor:
+                        future = executor.submit(get_next_item, dataset)
+                        try:
+                            item = future.result(timeout=10)
+                        except concurrent.futures.TimeoutError:
+                            print(f"timeout for get data from {dataset_name}")
+                            continue
+                        if item == "wtf_is_abnormal":
+                            print(f"too much abnormal from {dataset_name}, continue")
+                            continue
+                        if item == "max_bad_file_count_reached":
+                            print(f"{dataset_name} for this worker is corrupted, continue")
+                            continue
+                    batch_data = self.put_to_bucket( item, dataset_name)
+                    if batch_data is not None:
+                        yield batch_data
+
+        if self.enable_bucket:
+            return __bucket__iter()
+        else:
+            return __native__iter()
+
+    def state_dict(self):
+        output_state_dict = deepcopy(self.init_state_dict)
+        for dataset_name, local_cache_prefix in zip(self.dataset_names, self.local_cache_prefix_list):
+            if dataset_name not in self.init_state_dict:
+                continue
+            cache_list = glob.glob(f'{local_cache_prefix}*')
+            for cache_path in cache_list:
+                with open(cache_path, 'r') as f:
+                    for l in f.readlines():
+                        r = int(l.strip())
+                        output_state_dict[dataset_name]['seen_times'][r] += 1
+        return output_state_dict
+
+    def load_state_dict(self, state_dict):
+        for dataset_name, local_cache_prefix, dataset in zip(self.dataset_names, self.local_cache_prefix_list, self.dataset_list):
+            if dataset_name not in state_dict:
+                continue
+            if dataset_name not in self.init_state_dict:
+                continue
+            self.clean_cache(local_cache_prefix)
+            dataset.load_state_dict(state_dict[dataset_name])
+            self.init_state_dict[dataset_name] = dataset.state_dict
+
+    def clean_cache(self, local_cache_prefix):
+        for fname in glob.glob(f'{local_cache_prefix}*'):
+            try:
+                os.remove(fname)
+            except OSError:
+                pass
+
+    @classmethod
+    def create_dataset_function(cls, data, data_weights, **kwargs):
+        return cls(data, data_weights, **kwargs)
+
+
+
+class CollectionDataset(IterableDataset):
+    def __init__(
+        self,
+        train_data: list[str],
+        train_data_weights: list[int | float],
+        dataset_collections: Dict[str, Dict],
+        batch_size=1,
+        image_batch_size=48,
+        enable_bucket=False,
+        infinite=True,
+        shuffle=True,
+        local_cache='', # this should be a ByteNAS path
+        data_cache_prefix={'AIPVideoDataset': 'aip_dataset_cache'},
+    ):
+        # prepare for bucketings
+        self.enable_bucket = enable_bucket
+        self.batch_size = batch_size
+        self.image_batch_size = image_batch_size
+
+        self.buckets = {}
+        self.buckets_transform = {}
+        self.resolutions = set()
+        if not self.enable_bucket:
+            assert batch_size == 1, "if not enable_bucket, batch_size must be 1"
+
+        self.train_data_weights = train_data_weights
+
+        self.dataset_list = []
+        self.dataset_names = []
+        self.image_dataset_names = []
+        self.dataset_collections = dataset_collections
+        self.dataset_to_aspect_ratios = {}
+        self.init_state_dict = {}
+        self.local_cache_prefix_list = []
+        for data_name in train_data:
+            if data_name not in dataset_collections:
+                print(f'{data_name} not in dataset collections')
+                return
+            self.dataset_config = dataset_collections[data_name]
+            aspect_ratios = self.dataset_config['aspect_ratios']
+            self.dataset_to_aspect_ratios[data_name] = aspect_ratios
+            self.add_aspect_ratios(aspect_ratios)
+
+            module, cls = self.dataset_config['target'].rsplit(".", 1)
+            data_class = getattr(
+                importlib.import_module(module, package=None), cls)
+            if cls == 'T2IHDFSDataset':
+                self.image_dataset_names.append(data_name)
+
+            if cls in data_cache_prefix:
+                data_cache = os.path.join(local_cache, data_cache_prefix[cls])
+                os.makedirs(data_cache, exist_ok=True)
+                local_cache_prefix = os.path.join(data_cache, data_name)
+                self.clean_cache(local_cache_prefix)
+                self.dataset_config['params']['local_cache_prefix'] = local_cache_prefix
+                self.local_cache_prefix_list.append(local_cache_prefix)
+            else:
+                self.local_cache_prefix_list.append('')
+            dataset = data_class.create_dataset_function(
+                self.dataset_config['path'], None, **self.dataset_config['params'])
+            if cls == 'AIPVideoDataset':
+                self.init_state_dict[data_name] = dataset.state_dict
+            self.dataset_list.append(dataset)
+            self.dataset_names.append(data_name)
+
+        self.length = sum([len(dataset) for dataset in self.dataset_list])
+        self.dataset_iter_list = [iter(dataset) for dataset in self.dataset_list]
+
+    def add_aspect_ratios(self, aspect_ratios):
+        for key in aspect_ratios.keys():
+            self.buckets[key] = []
+
+        for key, sample_size in aspect_ratios.items():
+            sample_size = tuple(sample_size)
+            self.buckets_transform[key] = transforms.Compose([
+                transforms.Resize(min(sample_size[0], sample_size[1])), # fix when height > width
+                transforms.CenterCrop(sample_size),
+            ])
+        for h, w in aspect_ratios.values():
+            self.resolutions.add((49, h, w))
+
+    def get_bucket_id(self, item, dataset_name):
+        """
+        for large resolution data, we may have multiple bucket ids
+        """
+        frames, c, H, W = item['mp4'].shape
+        ratio = float(H) / float(W)
+
+        ratio_strategy = self.dataset_collections[dataset_name]['ratio_strategy']
+        ratios = self.dataset_to_aspect_ratios[dataset_name]
+        if ratio_strategy == 'random':
+            bucket_id = random.choice(list(ratios.keys()))
+        elif ratio_strategy == 'closest':
+            bucket_id = min(ratios.items(),
+                            key=lambda r: abs(float(r[1][0]) / float(r[1][1]) - ratio))[0]
+        else:
+            raise f"ratio_strategy {ratio_strategy} not support ..."
+
+        return bucket_id
+
+    def __len__(self):
+        return self.length
+
+    def crop_and_resize(self, image, h_prime, w_prime):
+        """
+        Crop and resize a 4D tensor image.
+
+        Args:
+            image: The input 4D tensor image of shape (frame, channel, h, w).
+            h_prime: Desired height of the cropped image.
+            w_prime: Desired width of the cropped image.
+
+        Returns:
+            The cropped and resized 4D tensor image.
+        """
+        frames, channels, h, w = image.shape
+        aspect_ratio_original = h / w
+        aspect_ratio_target = h_prime / w_prime
+
+        if aspect_ratio_original >= aspect_ratio_target:
+            new_h = int(w * aspect_ratio_target)
+            top = (h - new_h) // 2
+            bottom = top + new_h
+            left = 0
+            right = w
+        else:
+            new_w = int(h / aspect_ratio_target)
+            left = (w - new_w) // 2
+            right = left + new_w
+            top = 0
+            bottom = h
+        # print(f"left {left}, right {right}, top {top}, bottom {bottom}")
+        # Crop the image
+        cropped_image = image[:, :, top:bottom, left:right]
+        # Resize the cropped image
+        resized_image = F.resize(cropped_image, (h_prime, w_prime))
+        return resized_image
+
+    def _save_frames(self, frame_raw, uid, fps, stride=None, base_path="/mnt/bn/yufan-dev-my/ysh/Datasets/sft_sftnews_videos"):
+        if stride:
+            output_path = f"{base_path}/processed/stride{stride}"
+        else:
+            output_path = f"{base_path}/processed"
+        os.makedirs(output_path, exist_ok=True)
+        
+        save_list = []
+        frame_height, frame_width = None, None
+        for frame in frame_raw:
+            frame = (frame + 1) / 2 * 255
+            frame = transforms.ToPILImage()(frame.to(torch.uint8)).convert("RGB")
+            if frame_height is None:
+                frame_height, frame_width = frame.height, frame.width
+                video_path = f"{output_path}/{uid}_{len(frame_raw)}_{frame_height}_{frame_width}.mp4"
+                if os.path.exists(video_path):
+                    print(f"skip original video: {video_path}")
+                    return
+            save_list.append(frame)
+            frame = None
+            del frame
+
+        if not save_list:
+            return
+
+        export_to_video(save_list, video_path, fps=fps)
+        print(f"save to {video_path}")
+        
+        save_list = None
+        del save_list
+
+        free_memory()
+
+
+    def put_to_bucket(self, item, dataset_name):
+        bucket_id = self.get_bucket_id(item, dataset_name)
+        ori_frams, ori_c, ori_H, ori_W = item['mp4'].shape
+        ori_ratio = ori_H / ori_W
+        bucket_h, bucket_w = self.dataset_to_aspect_ratios[dataset_name][bucket_id][0], self.dataset_to_aspect_ratios[dataset_name][bucket_id][1]
+        bucket_ratio = bucket_h / bucket_w
+        # print(f"ori_H {ori_H}, ori_W {ori_W}, ori_ratio {ori_ratio}. bucket_h {bucket_h}, bucket_w {bucket_w}, bucket_ratio {bucket_ratio}")
+        item['mp4'] = self.crop_and_resize(item['mp4'], bucket_h, bucket_w)
+
+        # ----- save video -----
+        try:
+            if item["topk_avg_motion_scores_t"] >= 400:
+                base_path="/mnt/bn/yufan-dev-my/ysh/Datasets/sft_sftnews_videos/high_motion"
+            else:
+                base_path="/mnt/bn/yufan-dev-my/ysh/Datasets/sft_sftnews_videos/low_motion"
+            self._save_frames(item['mp4'], item["uttid"], item['fps'], base_path=base_path)
+
+            item["stride_mp4"] = self.crop_and_resize(item["stride_mp4"], bucket_h, bucket_w)
+            self._save_frames(item["stride_mp4"], item["uttid"], item['fps'], stride=item['stride'], base_path=base_path)
+        except:
+            pass
+        # ----- save video -----
+
+        # ----- save meta -----
+        if item["topk_avg_motion_scores_t"] >= 400:
+            base_path="/mnt/bn/yufan-dev-my/ysh/Datasets/sft_sftnews_videos/metadata/high_motion"
+        else:
+            base_path="/mnt/bn/yufan-dev-my/ysh/Datasets/sft_sftnews_videos/metadata/low_motion"
+        os.makedirs(base_path, exist_ok=True)
+        output_path = os.path.join(base_path, f"{item['uttid']}.json")
+        if not os.path.exists(output_path):
+            meta = {
+                "uttid": item["uttid"],
+                "text": item['txt'],
+                "ori_num_frames": item["ori_num_frames"],
+                "ori_height": item["ori_height"],
+                "ori_width": item["ori_width"],
+                "cur_num_frames": item["cur_num_frames"],
+                "cur_height": item['mp4'].shape[-2],
+                "cur_width": item['mp4'].shape[-1],
+                "topk_avg_motion_scores_t": item["topk_avg_motion_scores_t"],
+            }
+            with open(output_path, 'w',) as f:
+                json.dump(meta, f, indent=2)
+            print(f"save json to {output_path}")
+        # ----- save meta -----
+        
+        first_frame = item['mp4'][0]
+        item["first_frames_images"] = (first_frame + 1) / 2 * 255
+
+        frames, c, H, W = item['mp4'].shape
+        # rewrite item to the same format as the original dataset
+        new_item = {}
+        new_item['videos'] = item['mp4']
+        new_item['prompts'] = item['txt'] if item['txt'] is not None else "" # check text
+        new_item['video_metadata'] = {
+            'num_frames': frames,
+            'height': H,
+            'width': W,
+        }
+        new_item["first_frames_images"] = item["first_frames_images"]
+        new_item["uttid"] = item["uttid"]
+        new_item['stride_videos'] = item["stride_mp4"]
+        new_item["topk_avg_motion_scores_t"] = item["topk_avg_motion_scores_t"]
+        self.buckets[bucket_id].append(new_item)
+
+        batch = None
+        cur_batch_size = self.image_batch_size if bucket_id.startswith("i-") else self.batch_size
+        if len(self.buckets[bucket_id]) >= cur_batch_size:
+            batch = self.buckets[bucket_id]
+            self.buckets[bucket_id] = []
+
+        # item["uttid"] = None
+        # item['txt'] = None
+        # item["ori_num_frames"] = None
+        # item["ori_height"] = None
+        # item["ori_width"] = None
+        # item["cur_num_frames"] = None
+        # item['mp4'] = None
+        # item["topk_avg_motion_scores_t"] = None
+        # item["first_frames_images"] = None
+        # new_item['videos'] = None
+        # new_item['prompts'] = None
+        # new_item["first_frames_images"] = None
+        # new_item["uttid"] = None
+        # new_item['stride_videos'] = None
+        # new_item["topk_avg_motion_scores_t"] = None
+
+        new_item = None
+        item = None
+        meta = None
+        del meta
+        del item
+        del new_item
+        free_memory()
+
+        return batch
+
+    def __iter__(self):
+        def __native__iter():
+            while True:
+                dataset_idx = random.choices(
+                    list(range(len(self.dataset_list))), weights=self.dataset_weights)[0]
+                dataset = self.dataset_iter_list[dataset_idx]
+                yield next(dataset)
+
+        def __bucket__iter():
+            while True:
+                dataset_idx = random.choices(
+                    list(range(len(self.dataset_list))), weights=self.train_data_weights)[0]
+                dataset = self.dataset_iter_list[dataset_idx]
+                dataset_name = self.dataset_names[dataset_idx]
+                if dataset_name in self.image_dataset_names:
+                    replicate_times = max(int(self.image_batch_size / self.batch_size), 1)
+                    batch_data_list = []
+                    while replicate_times > 0:
+                        item = next(dataset)
+                        batch_data = self.put_to_bucket(item, dataset_name)
+                        if batch_data is not None:
+                            batch_data_list.append(batch_data)
+                        replicate_times -= 1
+                    for batch_data in batch_data_list:
+                        yield batch_data
+                else:
+                    item = next(dataset)
+                    batch_data = self.put_to_bucket(item, dataset_name)
+                    if batch_data is not None:
+                        yield batch_data
+
+        if self.enable_bucket:
+            return __bucket__iter()
+        else:
+            return __native__iter()
+
+    def state_dict(self):
+        output_state_dict = deepcopy(self.init_state_dict)
+        for dataset_name, local_cache_prefix in zip(self.dataset_names, self.local_cache_prefix_list):
+            if dataset_name not in self.init_state_dict:
+                continue
+            cache_list = glob.glob(f'{local_cache_prefix}*')
+            for cache_path in cache_list:
+                with open(cache_path, 'r') as f:
+                    for l in f.readlines():
+                        r = int(l.strip())
+                        output_state_dict[dataset_name]['seen_times'][r] += 1
+        return output_state_dict
+
+    def load_state_dict(self, state_dict):
+        for dataset_name, local_cache_prefix, dataset in zip(self.dataset_names, self.local_cache_prefix_list, self.dataset_list):
+            if dataset_name not in state_dict:
+                continue
+            if dataset_name not in self.init_state_dict:
+                continue
+            self.clean_cache(local_cache_prefix)
+            dataset.load_state_dict(state_dict[dataset_name])
+            self.init_state_dict[dataset_name] = dataset.state_dict
+
+    def clean_cache(self, local_cache_prefix):
+        for fname in glob.glob(f'{local_cache_prefix}*'):
+            try:
+                os.remove(fname)
+            except OSError:
+                pass
+
+    @classmethod
+    def create_dataset_function(cls, data, data_weights, **kwargs):
+        return cls(data, data_weights, **kwargs)

dataset_code/sft_sftnews/offload/dataset_tool/dataset_hdfs.py

@@ -0,0 +1,198 @@
+# -------------------------------------
+# Modified by: Jacob Zhiyuan Fang
+# Date: 2024/09/10
+# Email: jacob.fang@bytedance.com
+# Author: Xun Guo
+# Email: guoxun.99@bytedance.com
+# Date: 2024/05/29
+# -------------------------------------
+
+import os
+import json
+import time
+import random
+import subprocess
+
+import torch
+import numpy as np
+import tensorflow as tf
+import multiprocessing as mp
+import torchvision.transforms as transforms
+
+from .parquet_dataset.parquet_utils import get_random_for_rank_and_worker, get_portion_for_rank_and_worker
+from typing import List, Tuple
+from dataloader import KVReader
+from torch.utils.data.dataset import Dataset
+from torchvision.transforms.functional import to_pil_image
+
+from diffusers.training_utils import free_memory
+
+class T2VHDFSDataset(Dataset):
+    def __init__(self,
+                 json_path,
+                 sample_size=256,
+                 sample_stride=4,
+                 sample_n_frames=16,
+                 is_image=False,
+                 pick=False,
+                 fps=24,
+                 shuffle=True,
+                 infinite=True,
+                 ):
+        super().__init__()
+
+        with open(json_path, 'r') as jsonfile:
+            self.dataset = json.load(jsonfile)
+        assert type(
+            self.dataset) == list, "The annotation file should contain a list !!!"
+
+        # IMPORTANT: Prevent tf load tensor to GPU.
+        tf.config.set_visible_devices([], 'GPU')
+        self._context_features = {
+            'title': tf.io.FixedLenFeature([], dtype=tf.string)}
+        self._sequence_features = {
+            'data': tf.io.FixedLenSequenceFeature([], dtype=tf.string)}
+
+        self.length = len(self.dataset)
+        self.sample_n_frames = sample_n_frames
+        self.sample_stride = sample_stride
+        self.is_image = is_image
+        self.pick = pick
+        self.num_parallel_reader = 32
+        self.shuffle = shuffle
+        self.infinite = infinite
+        if sample_size == -1:  # if sample_size is None, using Identity transformation
+            self.pixel_transforms = transforms.Compose([
+                transforms.Lambda(lambda x: x)
+            ])
+        else:
+            sample_size = tuple(sample_size) if not isinstance(
+                sample_size, int) else (sample_size, sample_size)
+            self.pixel_transforms = transforms.Compose([
+                transforms.Resize(sample_size[0]),
+                transforms.CenterCrop(sample_size),
+            ])
+        self.fps = fps
+
+    def __iter__(self):
+        if self.shuffle:
+            get_random_for_rank_and_worker(None).shuffle(self.dataset)
+        part_dataset = get_portion_for_rank_and_worker(self.dataset)
+        while True:
+            if self.shuffle:
+                get_random_for_rank_and_worker(None).shuffle(part_dataset)
+            for idx in range(len(part_dataset)):
+                try:
+                    to_return = self.__getitem_impl__(idx)
+                    yield to_return
+                except (RuntimeError, ValueError):
+                    print('Appearing HDFS iops error setting src img \n' * 5)
+                    # idx = random.sample(range(self.length), 1)[0]
+            if not self.infinite:
+                break
+
+    def __len__(self):
+        return len(self.dataset)
+
+    def decode_image(self, raw_data):
+        return tf.image.decode_jpeg(raw_data, channels=3, dct_method='INTEGER_ACCURATE').numpy()
+
+    def get_batch(self, idx):
+        video_dict = self.dataset[idx]
+        video_name, index_file, caption = video_dict[
+            'video_name'], video_dict['index_file'], video_dict['caption']
+        reader = KVReader(index_file, self.num_parallel_reader)
+        keys = reader.list_keys()
+        assert video_name in keys, "video file not in this index file !!!"
+        values = reader.read_many([video_name])[0]
+
+        # Decode record
+        contexts, sequences = tf.io.parse_single_sequence_example(
+            serialized=values,
+            context_features=self._context_features,
+            sequence_features=self._sequence_features)
+
+        # Raw frames data
+        raw_frames = sequences['data']
+        del reader
+        video_length = len(raw_frames)
+
+        # Sample frames
+        if not self.is_image:
+
+            # Jacob Sep 17th: If sample frames > video frames, we drop this video
+            if (self.sample_n_frames - 1) * self.sample_stride + 1 > video_length:
+                return None, None
+            clip_length = min(
+                video_length, (self.sample_n_frames - 1) * self.sample_stride + 1)
+            start_idx = random.randint(0, video_length - clip_length)
+            batch_index = np.linspace(
+                start_idx, start_idx + clip_length - 1, self.sample_n_frames, dtype=int)
+        else:
+            batch_index = [random.randint(0, video_length - 1)]
+
+        # Decode frames
+        pixel_values = []
+        for idx in batch_index:
+            frame = raw_frames[idx]
+            frame = self.decode_image(frame)
+            frame = torch.as_tensor(frame).float().permute(2, 0, 1)
+            frame = (frame - 127.5) / 127.5
+            pixel_values.append(frame)
+
+        if self.is_image:
+            pixel_values = pixel_values[0]
+
+        pixel_values = torch.stack(pixel_values, dim=0)
+        return pixel_values, caption
+
+    def __getitem_impl__(self, idx, candidate=None):
+        # To avoid bad videos, we retry if there is an Exception.
+        # By default the size of videos are all 512, 910 so no need filter.
+        if candidate is None:
+            candidate = list(range(self.length))
+        while True:
+            try:
+                pixel_values, caption = self.get_batch(idx)
+
+                if pixel_values is None:
+                    # restart
+                    idx = random.sample(candidate, 1)[0]
+                else:
+                    # end the iteration
+                    break
+            except Exception as e:
+                print(f"VideoTextPairDataset got unexpected exception: {e}")
+                idx = random.sample(candidate, 1)[0]
+        pixel_values = self.pixel_transforms(pixel_values)
+
+        # pixel_values in shape of Frames x channel x H x W
+        sample = dict(
+            mp4=pixel_values,
+            txt=caption,
+            num_frames=self.sample_n_frames,
+            fps=self.fps,
+        )
+
+        return sample
+
+    @classmethod
+    def create_dataset_function(cls, json_path, args, **kwargs):
+        return cls(json_path=json_path, **kwargs)
+
+
+# Dataset unit test checking how many videos are not preferred
+if __name__ == "__main__":
+    dataset = T2VHDFSDataset(
+        json_path="/mnt/bn/icvg/video_gen/captions/pond5_res/pond5_data_res_human.json",
+        sample_size=512,
+        sample_stride=4,
+        sample_n_frames=49,
+        is_image=False,
+        pick=False,
+    )
+    dataloader = torch.utils.data.DataLoader(
+        dataset, batch_size=1, num_workers=1)
+    for idx, batch in enumerate(dataloader):
+        if idx % 100 == 0:
+            breakpoint()

dataset_code/sft_sftnews/offload/dataset_tool/image_dataset.py

@@ -0,0 +1,929 @@
+import os
+import sys
+import time
+import torch
+import random
+import bson, json
+from dataloader import KVReader, FalconReader
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Tuple
+from torch.utils.data.dataset import Dataset
+from torchvision.transforms import functional as TVF
+from torchvision.transforms.functional import InterpolationMode
+from torchvision.transforms import Compose, ToTensor, Normalize, RandomResizedCrop
+from pyarrow import fs, Field
+import pyarrow.parquet as  pq
+import numpy as np
+
+########## Utils ##########
+def hlist_files(folders, postfix=".index"):
+    """
+        罗列一些 hdfs 路径下的文件。
+    """
+    import subprocess
+    import os
+    if isinstance(folders, str):
+        folders = [folders]
+    files = []
+    for folder in folders:
+        if folder.startswith('hdfs'):
+            pipe = subprocess.Popen("hdfs dfs -ls -R {}".format(folder), shell=True,
+                                    stdout=subprocess.PIPE)
+            # output, _ = pipe.communicate()
+            for line in pipe.stdout:  # type: ignore
+                line = line.strip()
+                # drwxr-xr-x   - user group  4 file
+                if len(line.split()) < 5:
+                    continue
+                filepath = line.split()[-1].decode("utf8")
+                if filepath.endswith(postfix):
+                    files.append(filepath)
+            pipe.stdout.close()  # type: ignore
+            pipe.wait()
+        else:
+            return []
+    files = sorted(files)
+    return files
+
+
+def resize_crop(image, image_height, image_width, use_resize_random_crop=False):
+    aspect_ratio = image_width / image_height
+    if not use_resize_random_crop:
+        resize = RandomResizedCrop(
+            size=(image_height, image_width),  # Crop to target width height
+            scale=(1, 1),  # Do not scale.
+            ratio=(aspect_ratio, aspect_ratio),  # Keep target aspect ratio.
+            interpolation=InterpolationMode.LANCZOS  # Use LANCZO for downsample.
+        )
+        crop_top_coord, crop_left_coord, _, _ = resize.get_params(image, scale=(1, 1), ratio=(
+            aspect_ratio, aspect_ratio))
+        crop_coords_top_left = torch.tensor([crop_top_coord, crop_left_coord])
+        image = resize(image)
+    else:
+        image_aspect_ratio = image.width / image.height
+        if image_aspect_ratio >= aspect_ratio:
+            image_resize_h = image_height
+            image_resize_w = int(round(image_height * (image.width / image.height)))
+            crop_top_coord = 0
+            crop_left_coord = random.randint(0, image_resize_w - image_width)
+        else:
+            image_resize_w = image_width
+            image_resize_h = int(round(image_width * (image.height / image.width)))
+            crop_top_coord = random.randint(0, image_resize_h - image_height)
+            crop_left_coord = 0
+        image = TVF.resize(image, size=[image_resize_h, image_resize_w],
+                         interpolation=InterpolationMode.LANCZOS)
+        image = TVF.crop(image, crop_top_coord, crop_left_coord, image_height,
+                       image_width)
+        crop_coords_top_left = torch.tensor([crop_top_coord, crop_left_coord])
+    return image, crop_coords_top_left
+
+
+def partition_by_size(data: List[Any], size: int) -> List[List[Any]]:
+    """
+    Partition a list by size.
+    When indivisible, the last group contains fewer items than the target size.
+
+    Examples:
+        - data: [1,2,3,4,5]
+        - size: 2
+        - return: [[1,2], [3,4], [5]]
+    """
+    return [data[i:i+size] for i in range(0, len(data), size)]
+
+
+class timer:
+    def __init__(self, op, wait_seconds):
+        self.op = op
+        self.wait_seconds = wait_seconds
+
+    def __enter__(self):
+        self.start_time = time.time()
+
+    def __exit__(self, *exc_info):
+        self.stop_time = time.time()
+        self.elapsed_seconds = self.stop_time - self.start_time
+        if self.elapsed_seconds > self.wait_seconds:
+            print(f"Op: '{self.op}' took: {round(self.elapsed_seconds, 2)} seconds.", file=sys.stderr)
+
+
+########## ImageDecoder ##########
+import io
+from PIL import Image
+from base64 import b64decode
+from abc import abstractmethod
+
+class ImageDecoder:
+    """
+    Decode image from json dictionary.
+    Return None or raise exception if sample cannot be decoded to skip forward.
+    """
+    @abstractmethod
+    def __call__(self, item: Dict[str, Any]) -> Optional[Image.Image]:
+        raise NotImplementedError()
+
+
+class GeneralImageDecoder(ImageDecoder):
+    """
+    Read image from hdfs data entry, usually is in bytes format
+    """
+    def __init__(self):
+        # Avoid image too large warning messages.
+        Image.MAX_IMAGE_PIXELS = 1000000000
+
+    def __call__(self, item: Dict[str, Any]) -> Optional[Image.Image]:
+        image_data = item.get("image_org") or item.get("image") or item.get("binary")
+        if image_data is None:
+            return None
+
+        if isinstance(image_data, bytes):
+            image_bytes = image_data
+        else:
+            image_bytes = b64decode(image_data)
+
+        with Image.open(io.BytesIO(image_bytes)) as image:
+            if image.mode == "RGBA" or image.info.get("transparency", None) is not None:
+                image = image.convert("RGBA")
+                white = Image.new(mode="RGB", size=image.size, color=(255, 255, 255))
+                white.paste(image, mask=image.split()[3])
+                image = white
+            else:
+                image = image.convert("RGB")
+        return image
+
+
+########## ImagePredicate ##########
+class ImagePredicate:
+    """
+    Check if image satifiy a certaion requirements.
+    Return False if not satisfied and True if pass the check.
+
+    Be sure to pass key-value pair when using
+    """
+    @abstractmethod
+    def __call__(self, image: Image.Image, **kwargs) -> bool:
+        raise NotImplementedError()
+
+
+class ImageMultiPredicate(ImagePredicate):
+    def __init__(self, predicates: List[ImagePredicate]):
+        self.predicates = predicates
+
+    def __call__(self, image: Image.Image, **kwargs) -> bool:
+        for predicate in self.predicates:
+            if not predicate(image, **kwargs):
+                return False
+        return True
+
+
+class ImageBucketResolutionPredicate(ImagePredicate):
+    def __call__(self, image: Image.Image, bucket: Any, **kwargs) -> bool:
+        if image.size[0] < bucket.image_width or image.size[1] < bucket.image_height:
+            return False
+        return True
+
+
+class ImageAestheticPredicate(ImagePredicate):
+    def __init__(self, aes_thed=0):
+        self.aes_thed = aes_thed
+
+    def __call__(self, image: Image.Image, content: dict, **kwargs) -> bool:
+        return ("aesthetic" not in content) or (content["aesthetic"] >= self.aes_thed)
+
+
+########## TextCleaner ##########
+import re
+import ftfy
+import html
+import urllib.parse as ul
+from bs4 import BeautifulSoup
+
+class TextCleaner:
+    """
+    Clear up a caption with strange/improper contents
+    """
+    bad_punct_regex = re.compile(
+        r'[' + '#®•©™&@·º½¾¿¡§~' + '\)' + '\(' + '\]' + '\[' + '\}' + '\{' + '\|' + '\\' + '\/' + '\*' + r']{1,}')
+
+    def __call__(self, text):
+        # The exact text cleaning as was in the training stage:
+        text = self.clean_caption(text)
+        text = self.clean_caption(text)
+        return text
+
+    @staticmethod
+    def basic_clean(text):
+        text = ftfy.fix_text(text)
+        text = html.unescape(html.unescape(text))
+        return text.strip()
+
+    def clean_caption(self, caption):
+        caption = str(caption)
+        caption = ul.unquote_plus(caption)
+        caption = caption.strip().lower()
+        caption = re.sub('<person>', 'person', caption)
+        caption = re.sub('<br>', ' ', caption)
+        # urls:
+        caption = re.sub(
+            r'\b((?:https?:(?:\/{1,3}|[a-zA-Z0-9%])|[a-zA-Z0-9.\-]+[.](?:com|co|ru|net|org|edu|gov|it)[\w/-]*\b\/?(?!@)))',
+            # noqa
+            '', caption)  # regex for urls
+        caption = re.sub(
+            r'\b((?:www:(?:\/{1,3}|[a-zA-Z0-9%])|[a-zA-Z0-9.\-]+[.](?:com|co|ru|net|org|edu|gov|it)[\w/-]*\b\/?(?!@)))',
+            # noqa
+            '', caption)  # regex for urls
+        # html:
+        caption = BeautifulSoup(caption, features='html.parser').text
+
+        # @<nickname>
+        caption = re.sub(r'@[\w\d]+\b', '', caption)
+
+        # 31C0—31EF CJK Strokes
+        # 31F0—31FF Katakana Phonetic Extensions
+        # 3200—32FF Enclosed CJK Letters and Months
+        # 3300—33FF CJK Compatibility
+        # 3400—4DBF CJK Unified Ideographs Extension A
+        # 4DC0—4DFF Yijing Hexagram Symbols
+        # 4E00—9FFF CJK Unified Ideographs
+        caption = re.sub(r'[\u31c0-\u31ef]+', '', caption)
+        caption = re.sub(r'[\u31f0-\u31ff]+', '', caption)
+        caption = re.sub(r'[\u3200-\u32ff]+', '', caption)
+        caption = re.sub(r'[\u3300-\u33ff]+', '', caption)
+        caption = re.sub(r'[\u3400-\u4dbf]+', '', caption)
+        caption = re.sub(r'[\u4dc0-\u4dff]+', '', caption)
+        caption = re.sub(r'[\u4e00-\u9fff]+', '', caption)
+        #######################################################
+
+        # все виды тире / all types of dash --> "-"
+        caption = re.sub(
+            r'[\u002D\u058A\u05BE\u1400\u1806\u2010-\u2015\u2E17\u2E1A\u2E3A\u2E3B\u2E40\u301C\u3030\u30A0\uFE31\uFE32\uFE58\uFE63\uFF0D]+',
+            # noqa
+            '-', caption)
+
+        # кавычки к одному стандарту
+        caption = re.sub(r'[`´«»“”¨]', '"', caption)
+        caption = re.sub(r'[‘’]', "'", caption)
+
+        # &quot;
+        caption = re.sub(r'&quot;?', '', caption)
+        # &amp
+        caption = re.sub(r'&amp', '', caption)
+
+        # ip adresses:
+        caption = re.sub(r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}', ' ', caption)
+
+        # article ids:
+        caption = re.sub(r'\d:\d\d\s+$', '', caption)
+
+        # \n
+        caption = re.sub(r'\\n', ' ', caption)
+
+        # "#123"
+        caption = re.sub(r'#\d{1,3}\b', '', caption)
+        # "#12345.."
+        caption = re.sub(r'#\d{5,}\b', '', caption)
+        # "123456.."
+        caption = re.sub(r'\b\d{6,}\b', '', caption)
+        # filenames:
+        caption = re.sub(
+            r'[\S]+\.(?:png|jpg|jpeg|bmp|webp|eps|pdf|apk|mp4)', '', caption)
+
+        #
+        caption = re.sub(r'[\"\']{2,}', r'"', caption)  # """AUSVERKAUFT"""
+        caption = re.sub(r'[\.]{2,}', r' ', caption)  # """AUSVERKAUFT"""
+
+        # ***AUSVERKAUFT***, #AUSVERKAUFT
+        caption = re.sub(self.bad_punct_regex, r' ', caption)
+        caption = re.sub(r'\s+\.\s+', r' ', caption)  # " . "
+
+        # this-is-my-cute-cat / this_is_my_cute_cat
+        regex2 = re.compile(r'(?:\-|\_)')
+        if len(re.findall(regex2, caption)) > 3:
+            caption = re.sub(regex2, ' ', caption)
+
+        caption = self.basic_clean(caption)
+
+        caption = re.sub(r'\b[a-zA-Z]{1,3}\d{3,15}\b', '', caption)  # jc6640
+        caption = re.sub(r'\b[a-zA-Z]+\d+[a-zA-Z]+\b', '', caption)  # jc6640vc
+        caption = re.sub(r'\b\d+[a-zA-Z]+\d+\b', '', caption)  # 6640vc231
+
+        caption = re.sub(r'(worldwide\s+)?(free\s+)?shipping', '', caption)
+        caption = re.sub(r'(free\s)?download(\sfree)?', '', caption)
+        caption = re.sub(r'\bclick\b\s(?:for|on)\s\w+', '', caption)
+        caption = re.sub(
+            r'\b(?:png|jpg|jpeg|bmp|webp|eps|pdf|apk|mp4)(\simage[s]?)?', '', caption)
+        caption = re.sub(r'\bpage\s+\d+\b', '', caption)
+
+        # j2d1a2a...
+        caption = re.sub(
+            r'\b\d*[a-zA-Z]+\d+[a-zA-Z]+\d+[a-zA-Z\d]*\b', r' ', caption)
+
+        caption = re.sub(r'\b\d+\.?\d*[xх×]\d+\.?\d*\b', '', caption)
+
+        caption = re.sub(r'\b\s+\:\s+', r': ', caption)
+        caption = re.sub(r'(\D[,\./])\b', r'\1 ', caption)
+        caption = re.sub(r'\s+', ' ', caption)
+
+        caption.strip()
+
+        caption = re.sub(r'^[\"\']([\w\W]+)[\"\']$', r'\1', caption)
+        caption = re.sub(r'^[\'\_,\-\:;]', r'', caption)
+        caption = re.sub(r'[\'\_,\-\:\-\+]$', r'', caption)
+        caption = re.sub(r'^\.\S+$', '', caption)
+
+        return caption.strip()
+
+
+########## T2IHDFSDataset ##########
+@dataclass
+class Bucket:
+    index_files: List[str] = field(default_factory=list) # the .index filenames
+    image_count: int       = field(default=0)            # the total number of images
+    image_height: int      = field(default=0)            # the image height
+    image_width: int       = field(default=0)            # the image width
+
+class T2IHDFSDataset(Dataset):
+    def __init__(self, 
+                 hdfs_path, 
+                 resolution,
+                 caption_key,
+                 aspect_ratios,
+                 debug=False, 
+                 use_resize_random_crop=False,
+                 skip_caption_ratios=[0, 0.0655]):
+        super().__init__()
+
+        self.resolution = resolution
+        self.image_decoder = GeneralImageDecoder()
+        self.image_predicate = ImageMultiPredicate([
+            ImageAestheticPredicate(),
+            ImageBucketResolutionPredicate(),
+        ])
+        self.image_transform = Compose([
+            ToTensor(),
+            Normalize(mean=0.5, std=0.5),
+        ])
+        self.text_transform = TextCleaner()
+        self.caption_keys = caption_key
+        self.debug = debug
+        self.rank = 0 # mock value
+        self.use_resize_random_crop = use_resize_random_crop
+        self.skip_caption_ratios = skip_caption_ratios
+
+        self.buckets = dict()
+        self.bucket_override = list(map(lambda ratio: (ratio[0], ratio[1]), aspect_ratios.values())) # w, h
+
+        if isinstance(hdfs_path, str):
+            hdfs_path = [hdfs_path]
+        filepath_list = hlist_files(hdfs_path, postfix=".index")
+
+        for filepath in filepath_list:
+            # Parse name, example:
+            #  filepath:  "/laion5b_aesv2_512plus_buckets/2_19_256-896_00002_00196.index"
+            #  filename:  "/laion5b_aesv2_512plus_buckets/2_19_256-896_00002_00196"
+            #  basename:  "2_19_256-896_00002_00196"
+            #  extension: ".index"
+            filename, extension = os.path.splitext(filepath)
+            basename = os.path.basename(filename)
+
+            # Parse basename, example:
+            #  {id}_{image_count}_{image_height}-{image_width}_{other_info}
+            if extension in [".index", ".snappy"] and "tempstate" not in filename and 'tmp' not in filename:
+                image_count, image_height, image_width = basename.replace("_", "-").split("-")[1:4]
+                # skip invalid file.
+                try:
+                    image_count = int(image_count)
+                    image_height = int(image_height)
+                    image_width = int(image_width)
+                except:
+                    continue
+                if image_width <=0 or image_height<=0:
+                    continue
+
+                image_ratio = image_width / image_height
+                override_image_width, override_image_height = self._override_resolution_if_needed_v1(image_width,
+                                                                                image_height)
+                override_image_ratio = override_image_width / override_image_height
+                # Omit buckets with unreasonable size ratio, such as (128, 1536)
+                if override_image_ratio / image_ratio > 1.5 or override_image_ratio / image_ratio < 0.7:
+                    continue
+
+                bucket_key = (override_image_width, override_image_height)
+                bucket_entry = self.buckets.get(bucket_key, Bucket())
+                bucket_entry.index_files.append(filename)
+                bucket_entry.image_count += image_count
+                bucket_entry.image_height = override_image_height
+                bucket_entry.image_width = override_image_width
+                self.buckets[bucket_key] = bucket_entry
+
+        for i, bucket_entry in enumerate(self.buckets.values()):
+            print(
+                f"Bucket {i}: {bucket_entry.image_width}x{bucket_entry.image_height} " +
+                f"contains {bucket_entry.image_count} images."
+            )
+        print(f"Total samples: {sum([bucket_entry.image_count for bucket_entry in self.buckets.values()])}")
+
+    def _override_resolution_if_needed_v1(self, width: int, height: int) -> Tuple[int, int]:
+        """
+        Override the bucket resolution if configured:
+        Example:
+            - bucket override: [(1000, 200), (200, 1000)]
+            - current resolution: (300, 900)
+            - return (200, 1000) because it is the closest in aspect ratio.
+        """
+        if self.bucket_override is not None:
+            # If bucket override is defined, find a new resolution from the override list that best matches the aspect ratio.
+            assert len(self.bucket_override) > 0, "bucket_override must not be an empty list."
+            target_aspect_ratio = width / height
+            bucket_resolutions = self.bucket_override
+            bucket_aspect_ratios = torch.tensor([w / h for w, h in bucket_resolutions], dtype=torch.float64)
+            bucket_idx = bucket_aspect_ratios.sub(target_aspect_ratio).abs().argmin().item()
+            width, height = bucket_resolutions[bucket_idx]
+
+        if self.resolution != 512:
+            # The buckets are defined in 512 resolution. If target resolution is not 512, we need to scale it and make sure divisible by 64.
+            ratio = self.resolution / 512
+            width = (width * ratio) // 64 * 64
+            height = (height * ratio) // 64 * 64
+
+        return int(width), int(height)
+
+    def __len__(self):
+        return sum(bucket.image_count for bucket in self.buckets.values())
+
+    def __iter__(self):
+        bucket_entries = list(self.buckets.values())
+        bucket_weights = list(map(lambda bucket: bucket.image_count, bucket_entries))
+        bucket_iterators = list(map(lambda bucket: self._iterate_bucket(bucket), bucket_entries))
+
+        while True:
+            try:
+                bucket_iterator = random.choices(bucket_iterators, bucket_weights)[0]
+                bucket, index_file, key, content, image, original_size_as_tuple = next(bucket_iterator)
+                # get caption
+                text = self.get_caption(content)
+                # Skip sample if text returned None.
+                if text is None:
+                    if self.debug: print("text is None")
+                    continue
+
+                if self.debug:
+                    print(f"Original_size_as_tuple {original_size_as_tuple}")
+                    print(f"Image size: {image.size}")
+                    print(f"Text length: {len(text)}")
+
+                # Resize and crop image
+                with timer(op=f"[Rank:{self.rank}] Resize image from {index_file}, key: {key}", wait_seconds=2):
+                    image, crop_coords_top_left = resize_crop(image, bucket.image_height,
+                                                                bucket.image_width, self.use_resize_random_crop)
+
+                # Transform image and text
+                with timer(op=f"[Rank:{self.rank}] Transform image and text from {index_file}, key: {key}",
+                            wait_seconds=2):
+                    if self.image_transform is not None:
+                        image = self.image_transform(image)
+                        image = image.unsqueeze(0) # Add temporal dim
+
+                    # filter pure black image
+                    if isinstance(image, torch.Tensor) and image.std() < 0.02 and image.mean() < -0.9:
+                        if self.debug: print("image is too dark")
+                        continue
+
+                    if self.text_transform is not None:
+                        text = self.text_transform(text)
+                    if text == "":
+                        if self.debug: print("text is empty")
+                        continue
+
+                if self.debug:
+                    print(f"dataset loading current text: en is {text}")
+
+                item = dict(
+                    mp4=image,
+                    txt=text,
+                    num_frames=1
+                )
+                yield item
+            except Exception as ex:
+                raise ex
+                # Error should not happen here, but we add a guard anyway.
+                #print(f"Bucket dataset processing sample received unexpected exception at file: {index_file}", ex,
+                #     file=sys.stderr)
+                continue
+
+    def _iterate_bucket(self, bucket: Bucket):
+        # Copy the list.
+        index_files = list(bucket.index_files)
+        count_unsatisfy_image_predicor = 0
+        while True:
+            # Shuffle files
+            random.shuffle(index_files)
+            # Loop through all the .index files
+            for index_file in index_files:
+                try:
+                    with timer(
+                        op=f"[Rank:{self.rank}] KVReader opens and lists keys from index file {index_file}",
+                        wait_seconds=3
+                    ):
+                        reader = FalconReader(index_file)
+                        keys = reader.list_keys()
+
+                    # We devide keys to batches then shuffle the batch order.
+                    # Note that keys within a batch are still contiguous for faster data loading.
+                    keys_batches = partition_by_size(keys, 64)
+                    random.shuffle(keys_batches)
+
+                    for key_batch in keys_batches:
+                        with timer(
+                            op=f"[Rank:{self.rank}] KVReader reads values from index file {index_file}, keys: {key_batch}",
+                            wait_seconds=10,
+                        ):
+                            # Read values. The keys within this batch are contiguous for faster loading.
+                            value_batch = reader.read_many(key_batch)
+
+                            # Shuffle samples within this batch.
+                            key_value_batch = list(zip(key_batch, value_batch))
+                            random.shuffle(key_value_batch)
+
+                        for key, value in key_value_batch:
+                            # Decode json
+                            with timer(op=f"[Rank:{self.rank}] Decoding bson/json from {index_file}, key: {key}",
+                                       wait_seconds=2):
+                                try:
+                                    content = bson.loads(value)
+                                except:
+                                    content = json.loads(value)
+
+                            # Decode image
+                            with timer(op=f"[Rank:{self.rank}] Decoding image from {index_file}, key: {key}",
+                                       wait_seconds=2):
+                                image = self.image_decoder(content)
+                                original_size_as_tuple = torch.tensor([image.height, image.width])
+                            # check if image meets requirements, skip if not
+                            if image is None:
+                                if self.debug: print("find empty image")
+                                continue
+                            if self.image_predicate is not None and \
+                                    not self.image_predicate(image=image, content=content, bucket=bucket):
+                                if self.debug: print("image does not satifiy image predicates", index_file)
+                                count_unsatisfy_image_predicor += 1
+                                # Find the consecutive 500 samples that do not satisfy image_predicate.
+                                # This kv file may cause the dataloader queue to be empty,
+                                # leading to program interruption. Therefore, skip this kv file.
+                                if count_unsatisfy_image_predicor > 500:
+                                    count_unsatisfy_image_predicor = 0
+                                    raise RuntimeError("Find invalid kv file, skip!")
+                                continue
+                            else:
+                                count_unsatisfy_image_predicor = 0
+                            yield bucket, index_file, key, content, image, original_size_as_tuple
+
+                except Exception as ex:
+                    # Error may happen due to network issue when reading from data from this file.
+                    # Skip to the next index file regardless.
+                    print(f"Bucket dataset reading data received unexpected exception at file: {index_file}", ex, file=sys.stderr)
+                    continue
+
+    def get_caption(self, content):
+        text_key = None
+        if len(self.caption_keys) == 1: # only one key
+            res = content.get(self.caption_keys[0], None)
+        else: # 2 or more keys
+            for caption_key, skip_ratio in zip(self.caption_keys, self.skip_caption_ratios):
+                r1 = random.random()
+                if r1 >= skip_ratio and content.get(caption_key, None) is not None:
+                    text_key = caption_key
+                    break
+            # if all previous captions are skipped, use the last one (original caption)
+            if text_key is None:
+                if self.debug:
+                    print("v1 {} v2 {} use original caption".format(self.caption_keys[0] in content, self.caption_keys[1] in content))
+                res = content.get(self.caption_keys[-1], None)
+            else:
+                if self.debug:
+                    print("v1 {} v2 {} use {}".format(self.caption_keys[0] in content, self.caption_keys[1] in content, text_key))
+                res  = content[text_key]
+        if res is None:
+            return None
+        else:
+            return res["text"]
+
+    @classmethod
+    def create_dataset_function(cls, hdfs_path, args, **kwargs):
+        return cls(hdfs_path=hdfs_path, **kwargs)
+
+
+class T2IHDFSDataset_dump(Dataset):
+    def __init__(self, 
+                 hdfs_path, 
+                 resolution,
+                 caption_key,
+                 aspect_ratios,
+                 debug=False, 
+                 use_resize_random_crop=False,
+                 skip_caption_ratios=[0, 0.0655]):
+        super().__init__()
+        ###delete
+        self.resolution = resolution
+        self.image_decoder = GeneralImageDecoder()
+        self.image_predicate = ImageMultiPredicate([
+            ImageAestheticPredicate(),
+            ImageBucketResolutionPredicate(),
+        ])
+        self.image_transform = Compose([
+            ToTensor(),
+            Normalize(mean=0.5, std=0.5),
+        ])
+        self.text_transform = TextCleaner()
+        self.caption_keys = caption_key
+        self.debug = debug
+        self.rank = 0 # mock value
+        self.use_resize_random_crop = use_resize_random_crop
+        self.skip_caption_ratios = skip_caption_ratios
+
+        self.buckets = dict()
+        self.bucket_override = list(map(lambda ratio: (ratio[0], ratio[1]), aspect_ratios.values())) # w, h
+        if isinstance(hdfs_path, str):
+            hdfs_path = [hdfs_path]
+        filepath_list = hlist_files(hdfs_path, postfix=".parquet")
+
+        for filepath in filepath_list:
+            # Parse name, example:
+            #  filepath:  "/laion5b_aesv2_512plus_buckets/2_19_256-896_00002_00196.index"
+            #  filename:  "/laion5b_aesv2_512plus_buckets/2_19_256-896_00002_00196"
+            #  basename:  "2_19_256-896_00002_00196"
+            #  extension: ".index"
+            filename, extension = os.path.splitext(filepath)
+            basename = os.path.basename(filename)
+
+            # Parse basename, example:
+            #  {id}_{image_count}_{image_height}-{image_width}_{other_info}
+            if 'good' in filename and extension in [".parquet"]:
+                image_count, image_height, image_width = basename.replace("_", "-").split("-")[2:5]
+            elif extension in [".parquet"]:
+                image_count, image_height, image_width = basename.replace("_", "-").split("-")[1:4]
+                # skip invalid file.
+            try:
+                image_count = int(image_count)
+                image_height = int(image_height)
+                image_width = int(image_width)
+            except:
+                continue
+            if image_width <=0 or image_height<=0:
+                continue
+
+            image_ratio = image_width / image_height
+            override_image_width, override_image_height = self._override_resolution_if_needed_v1(image_width,
+                                                                            image_height)
+            override_image_ratio = override_image_width / override_image_height
+            # Omit buckets with unreasonable size ratio, such as (128, 1536)
+            if override_image_ratio / image_ratio > 1.5 or override_image_ratio / image_ratio < 0.7:
+                continue
+
+            bucket_key = (override_image_width, override_image_height)
+            bucket_entry = self.buckets.get(bucket_key, Bucket())
+            bucket_entry.index_files.append(filename)
+            bucket_entry.image_count += image_count
+            bucket_entry.image_height = override_image_height
+            bucket_entry.image_width = override_image_width
+            self.buckets[bucket_key] = bucket_entry
+
+        for i, bucket_entry in enumerate(self.buckets.values()):
+            print(
+                f"Bucket {i}: {bucket_entry.image_width}x{bucket_entry.image_height} " +
+                f"contains {bucket_entry.image_count} images."
+            )
+        print(f"Total samples: {sum([bucket_entry.image_count for bucket_entry in self.buckets.values()])}")
+
+    def _override_resolution_if_needed_v1(self, width: int, height: int) -> Tuple[int, int]:
+        """
+        Override the bucket resolution if configured:
+        Example:
+            - bucket override: [(1000, 200), (200, 1000)]
+            - current resolution: (300, 900)
+            - return (200, 1000) because it is the closest in aspect ratio.
+        """
+        if self.bucket_override is not None:
+            # If bucket override is defined, find a new resolution from the override list that best matches the aspect ratio.
+            assert len(self.bucket_override) > 0, "bucket_override must not be an empty list."
+            target_aspect_ratio = width / height
+            bucket_resolutions = self.bucket_override
+            bucket_aspect_ratios = torch.tensor([w / h for w, h in bucket_resolutions], dtype=torch.float64)
+            bucket_idx = bucket_aspect_ratios.sub(target_aspect_ratio).abs().argmin().item()
+            width, height = bucket_resolutions[bucket_idx]
+
+        if self.resolution != 512:
+            # The buckets are defined in 512 resolution. If target resolution is not 512, we need to scale it and make sure divisible by 64.
+            ratio = self.resolution / 512
+            width = (width * ratio) // 64 * 64
+            height = (height * ratio) // 64 * 64
+
+        return int(width), int(height)
+
+    def __len__(self):
+        return sum(bucket.image_count for bucket in self.buckets.values())
+
+    def __iter__(self):
+        bucket_entries = list(self.buckets.values())
+        bucket_weights = list(map(lambda bucket: bucket.image_count, bucket_entries))
+        bucket_iterators = list(map(lambda bucket: self._iterate_bucket(bucket), bucket_entries))
+
+        while True:
+            try:
+                bucket_iterator = random.choices(bucket_iterators, bucket_weights)[0]
+                bucket, content, image, original_size_as_tuple = next(bucket_iterator)
+
+                if self.resolution == 256:
+                    latent = np.frombuffer(content['latent_256'], dtype=np.float32)
+                    latent = latent.reshape(content['latent_256_size'])
+                    latent = torch.from_numpy(latent).to(torch.bfloat16)
+                if self.resolution == 512:
+                    latent = np.frombuffer(content['latent_512'], dtype=np.float32)
+                    latent = latent.reshape(content['latent_512_size'])
+                    latent = torch.from_numpy(latent).to(torch.bfloat16)
+
+                image, crop_coords_top_left = resize_crop(image, bucket.image_height,
+                                                            bucket.image_width, self.use_resize_random_crop)
+                if self.image_transform is not None:
+                    image = self.image_transform(image)
+                    image = image.unsqueeze(0) # Add temporal dim
+
+                # get caption
+                image_crop_256 = content.get('image_crop_256')
+                if image_crop_256 is not None:
+                    text = self.get_caption_new(content)
+                else:
+                    text = self.get_caption(content)
+                # Skip sample if text returned None.
+                if text is None:
+                    if self.debug: print("text is None")
+                    continue
+
+                # Transform image and text
+                if self.text_transform is not None:
+                    text = self.text_transform(text)
+                if text == "" or text == 'none':
+                    if self.debug: print("text is empty")
+                    continue
+
+                if self.debug:
+                    print(f"dataset loading current text: en is {text}")
+
+                item = dict(
+                    mp4=image,
+                    latent = latent,
+                    txt=text,
+                    num_frames=1
+                )
+                yield item
+            except Exception as ex:
+                raise ex
+                # Error should not happen here, but we add a guard anyway.
+                #print(f"Bucket dataset processing sample received unexpected exception at file: {index_file}", ex,
+                #     file=sys.stderr)
+                continue
+
+    def _iterate_bucket(self, bucket: Bucket):
+        # Copy the list.
+        index_files = list(bucket.index_files)
+        count_unsatisfy_image_predicor = 0
+        while True:
+            # Shuffle files
+            random.shuffle(index_files)
+            # Loop through all the .index files
+            for index_file in index_files:
+                try:
+                    ##read parquet file
+                    filesystem = fs.HadoopFileSystem('hdfs://harunasg', 0)
+                    index_file = index_file + '.parquet'
+                    with pq.ParquetFile(index_file, filesystem=filesystem) as fr:
+                        # print(f'--- total: {fr.metadata.num_rows} ---- {fr.num_row_groups}')
+                        # keys = []
+                        # for i in range(fr.num_row_groups):
+                        #     # 读取当前的 Row Group
+                        #     row_group = fr.read_row_group(i).to_pylist()
+                        #     keys += row_group
+                        random_index = random.randint(0, fr.num_row_groups - 1)
+                        keys = fr.read_row_group(random_index).to_pylist()   
+                                             
+                    # We devide keys to batches then shuffle the batch order.
+                    # Note that keys within a batch are still contiguous for faster data loading.
+                    keys_batches = partition_by_size(keys, 64)
+                    random.shuffle(keys_batches)
+
+                    for key_batch in keys_batches:
+                        random.shuffle(key_batch)
+
+                        for content in key_batch:
+                            if self.resolution == 256:
+                                latent = content['latent_256']
+                            else:
+                                latent = content['latent_512']
+                            if not latent:
+                                count_unsatisfy_image_predicor += 1
+                                # Find the consecutive 500 samples that do not satisfy image_predicate.
+                                # This kv file may cause the dataloader queue to be empty,
+                                # leading to program interruption. Therefore, skip this kv file.
+                                if count_unsatisfy_image_predicor > 500:
+                                    count_unsatisfy_image_predicor = 0
+                                    raise RuntimeError("Find invalid kv file, skip!")
+                                continue                                
+                            else:
+                                count_unsatisfy_image_predicor = 0
+                            image = self.image_decoder(content)
+                            original_size_as_tuple = torch.tensor([image.height, image.width])
+
+                            yield bucket, content, image, original_size_as_tuple
+
+                except Exception as ex:
+                    # Error may happen due to network issue when reading from data from this file.
+                    # Skip to the next index file regardless.
+                    print(f"Bucket dataset reading data received unexpected exception at file: {index_file}", ex, file=sys.stderr)
+                    continue
+
+    def get_caption(self, content):
+        text_key = None
+        if len(self.caption_keys) == 1: # only one key
+            res = content.get(self.caption_keys[0], None)
+        else: # 2 or more keys
+            for caption_key, skip_ratio in zip(self.caption_keys, self.skip_caption_ratios):
+                r1 = random.random()
+                if r1 >= skip_ratio and content.get(caption_key, None) is not None:
+                    text_key = caption_key
+                    break
+            # if all previous captions are skipped, use the last one (original caption)
+            if text_key is None:
+                if self.debug:
+                    print("v1 {} v2 {} use original caption".format(self.caption_keys[0] in content, self.caption_keys[1] in content))
+                res = content.get(self.caption_keys[-1], None)
+            else:
+                if self.debug:
+                    print("v1 {} v2 {} use {}".format(self.caption_keys[0] in content, self.caption_keys[1] in content, text_key))
+                res  = content[text_key]
+        if res is None:
+            return None
+        else:
+            return res
+    def get_caption_new(self, content):
+        caption_dict = json.loads(content['caption_dict'])
+        caption_list = []
+        for k, v in caption_dict.items():
+            if '_en_' in k and '_text' in k:
+                caption_list.append(v)
+        if len(caption_list) == 0:
+            return None
+        res = random.choice(caption_list)
+        return res
+
+    @classmethod
+    def create_dataset_function(cls, hdfs_path, args, **kwargs):
+        return cls(hdfs_path=hdfs_path, **kwargs)
+
+
+if __name__ == "__main__":
+    from omegaconf import OmegaConf
+    from torch.utils.data import DataLoader
+    from torch.utils.data.distributed import DistributedSampler
+    from matplotlib import pyplot as plt
+    import numpy as np
+    from training.dataset_tool import CollectionDataset, collate_fn_map
+
+    hdfs_path = "hdfs://harunasg/home/byte_icvg_aigc_cp/user/seed_t2i/kexuanyi/data/train_data/pretrained_data/kv/v2.0/pretrained_en/v2.0_data_512_src_data"
+    config = "/mnt/bn/icvg/users/minxuan.lin/Workspace/video-factory/config/dataset_config/test_collection_config_sg.yaml"
+    seed = 0
+
+    # set seed
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+
+    configs = OmegaConf.load(config)
+    train_dataset = CollectionDataset.create_dataset_function(configs['train_data'],
+                                                            configs['train_data_weights'],
+                                                            **configs['data']['params'])
+    # train_dataset = T2IHDFSDataset.create_dataset_function(hdfs_path=hdfs_path, args=None, **configs['data']['params']['dataset_collections']['seedv2-t2i']['params'])
+
+    # sampler = DistributedSampler(train_dataset, rank=rank, num_replicas=world_size,)
+    train_dataloader = DataLoader(
+        train_dataset,
+        batch_size=1,
+        num_workers=1,
+        collate_fn=collate_fn_map,
+        pin_memory=False
+    )
+
+    output_dir = "outputs/test1"
+    os.makedirs(output_dir, exist_ok=True)
+
+    for i, batch in enumerate(train_dataloader):
+        print(batch.keys())
+        print(batch['prompts'])
+        print(batch['videos'].size())
+        print(batch['video_metadata'])
+        print(torch.min(batch['videos']), torch.max(batch['videos']))
+        for j in range(batch['videos'].size()[0]):
+            plt.imsave(f"{output_dir}/test_{i}_{j}.jpg", ((batch['videos'][j,0,...]+1)*127.5).permute(1,2,0).numpy().astype(np.uint8))
+        if i > 20:
+            break

dataset_code/sft_sftnews/offload/dataset_tool/parquet_dataset/base_parquet.py

@@ -0,0 +1,289 @@
+from itertools import chain
+from multiprocessing import Pool
+from pyarrow.parquet import ParquetFile
+from torch.utils.data import IterableDataset
+from typing import List, Literal, Optional, Union
+from pyarrow.fs import HadoopFileSystem, LocalFileSystem
+
+from .utils.hdfs_utils import listdir_with_metafile, exists
+from .parquet_utils import (
+    get_portion_for_worker_only,
+    get_random_for_rank_and_worker,
+    get_portion_for_rank_and_worker,
+)
+
+def hack_s_data(filepath):
+    if "vae-1011" in filepath:
+        return filepath.replace("byte_data_tt_m/VGFM/data/packed/vae-1011", "byte_icvg_aigc_cp/user/video/temp/19900101/packed/vae-1011")
+    elif "dit-1126" in filepath:
+        return filepath.replace("byte_data_tt_m/user/sheng.bi/vgfm/packed/dit-1126", "byte_icvg_aigc_cp/user/video/temp/19900101/dit-1126")
+    else:
+        return filepath
+
+def get_filesystem(path: str) -> Union[LocalFileSystem, HadoopFileSystem]:
+    """
+    Get filesystem based on the path.
+    """
+    if path.startswith("hdfs://"):
+        return HadoopFileSystem.from_uri(path)
+    else:
+        return LocalFileSystem()
+
+
+def read_metadata(
+    path: str,
+):
+    fs = get_filesystem(path)
+    with ParquetFile(path, filesystem=fs) as file:
+        metadata = file.metadata
+    return metadata
+
+
+class ParquetDataset(IterableDataset):
+    """
+    Parquet dataset.
+
+    Arguments:
+        path: a directory path that contains *.parquet files.
+        seed: seed for deterministic sampling. If None, just random.
+        partition: partition strategy. Split by *.parquet file or by row groups in each file.
+        force_partition: if True, raise error if partition is indivisible.
+        num_parallel_files: number of parallel files to read.
+        infinite: If True, data will be returned infinitely.
+    """
+
+    def __init__(
+        self,
+        path: Union[str, List[str]],
+        seed: Optional[int],
+        partition: Literal["file", "group", "dump"] = "file",
+        force_partition: bool = False,
+        num_parallel_files: int = 8,
+        infinite: bool = True,
+        path_mode: Literal["dir", "file"] = "dir",
+        shuffle: bool = True,
+        columns: Optional[List[str]] = None,
+        plugin_caption_path="",
+        dump_path = "",
+    ):
+        assert partition in ["file", "group", "dump"]
+        assert path_mode in ["dir", "file"]
+
+        # Save settings.
+        self.seed = seed
+        self.infinite = infinite
+        self.partition = partition
+        self.force_partition = force_partition
+        self.num_parallel_files = num_parallel_files
+        self.shuffle = shuffle
+        self.columns = columns
+
+        # List file paths.
+        filepaths = path if isinstance(path, list) else [path]
+        if path_mode == "dir":
+            filepaths = map(listdir_with_metafile, filepaths)
+            filepaths = chain(*filepaths)
+        filepaths = filter(lambda path: path.endswith(".parquet"), filepaths)
+        filepaths = [hack_s_data(path) for path in filepaths]
+        filepaths = sorted(filepaths)
+        assert len(filepaths) > 0
+
+        # Create file readers.
+        self.filereaders = [
+            ParquetFileReader(
+                path=path,
+                seed=seed,
+                partition=partition,
+                force_partition=force_partition,
+                shuffle=shuffle,
+                columns=columns,
+                plugin_caption_path=plugin_caption_path.rstrip(
+                    '/')+"/"+path.split('/')[-1] if plugin_caption_path != "" else "",
+                dump_path = dump_path.rstrip(
+                    '/')+"/"+path.split('/')[-1] if dump_path != "" else "",
+            )
+            for path in filepaths
+        ]
+
+    # Please don't use a fake __len__(self)! Try making other functions e.g. get_size() instead.
+    def __len__(self):
+        if not hasattr(self, "count"):
+            # Calculate an approximate dataset item count.
+            # We open 5 files and compute the average items per file.
+            # Then we use this to approximate total dataset item count.
+
+            with Pool(1) as pool:
+                counts = pool.map(len, self.filereaders[:5])
+            self.count = int(sum(counts) / len(counts) * len(self.filereaders))
+        return self.count
+
+    def __iter__(self):
+        epoch = 0
+        filereaders = self.filereaders
+        random = get_random_for_rank_and_worker(self.seed)
+
+        # Partition by files if needed.
+        if self.partition == "file":
+            filereaders = get_portion_for_rank_and_worker(
+                filereaders, self.force_partition)
+
+        while True:
+            # Initialize filereaders iterators.
+            if len(filereaders) == 0:
+                filereaders = get_portion_for_rank_and_worker(
+                    self.filereaders, self.force_partition, resample = True)               
+            iterators = [reader.__iter__(epoch=epoch)
+                         for reader in filereaders]
+            if self.shuffle:
+                random.shuffle(iterators)
+
+            # Yield samples.
+            bad_file_count = 0
+            max_bad_file_count = len(iterators)
+            while any(iterators):
+                if self.shuffle:
+                    iterator = random.choice(
+                        iterators[: self.num_parallel_files])
+                else:
+                    iterator = iterators[0]
+                try:
+                    result = next(iterator)
+                    if result == "invalid parquet file!":
+                        print("encounter data-caption file problem, removing iterator")
+                        iterators.remove(iterator)
+                        bad_file_count += 1
+                        if bad_file_count >= max_bad_file_count:
+                            bad_file_count = 0
+                            yield "max_bad_file_count_reached"
+                        continue
+                    else:
+                        yield result
+                except StopIteration:
+                    iterators.remove(iterator)
+
+            # Break after the first epoch if not infinite.
+            if not self.infinite:
+                break
+
+            # Increment epoch.
+            epoch += 1
+
+
+class ParquetFileReader:
+    """
+    Read a single *.parquet file.
+
+    Arguments:
+        path: a *.parquet file path.
+        seed: seed for deterministic sampling. If None, just random.
+        partition: partition strategy.
+        force_partition: if True, raise error if partition is indivisible.
+    """
+
+    def __init__(
+        self,
+        path: str,
+        seed: Optional[int],
+        partition: bool,
+        force_partition: bool,
+        shuffle: bool,
+        columns: Optional[List[str]],
+        plugin_caption_path: str,
+        dump_path: str,
+    ):
+        self.path = path
+        self.seed = seed
+        self.partition = partition
+        self.force_partition = force_partition
+        self.shuffle = shuffle
+        self.columns = columns
+        self.plugin_caption_path = plugin_caption_path
+        self.dump_path = dump_path
+
+    def __len__(self):
+        fs = get_filesystem(self.path)
+        with ParquetFile(self.path, filesystem=fs) as file:
+            return file.metadata.num_rows
+
+    def __iter_parallel(self, epoch):
+        fs = get_filesystem(self.path)
+        print(self.path)
+        if not exists(self.path) or not exists(self.plugin_caption_path) or not exists(self.dump_path):
+            # return and make the iter empty
+            print(f"parallel loading warning: {self.path} or {self.plugin_caption_path} not exists, return empty iter")
+            yield "invalid parquet file!"
+        with ParquetFile(self.path, filesystem=fs) as file, \
+                ParquetFile(self.plugin_caption_path, filesystem=fs) as plugin_caption, \
+                    ParquetFile(self.dump_path, filesystem=fs) as dump_file:
+            # List all groups.
+            groups = list(range(file.num_row_groups))
+
+            # Partition groups if needed.
+            if self.partition == "group":
+                groups = get_portion_for_rank_and_worker(
+                    groups, self.force_partition)
+            elif self.partition == "dump":
+                groups = get_portion_for_worker_only(groups)
+
+            if self.shuffle:
+                # Shuffle groups
+                seed = (self.seed + epoch) if self.seed is not None else None
+                get_random_for_rank_and_worker(seed).shuffle(groups)
+
+            # Iteration over all samples from all row groups.
+            for group in groups:
+                print(group)
+                iter_main = file.iter_batches(
+                    batch_size=1, row_groups=[group], columns=self.columns,
+                    use_threads=False,)
+                iter_plugin_caption = plugin_caption.iter_batches(
+                    batch_size=1, row_groups=[group], columns=None,
+                    use_threads=False,)
+                iter_dump = dump_file.iter_batches(
+                    batch_size=1, row_groups=[group], columns=None,
+                    use_threads=False,)
+
+                # Zip the two iterators to read rows "in parallel"
+                for main_batch, caption_batch, dump_batch in zip(iter_main, iter_plugin_caption, iter_dump):
+                    # Convert each single-row batch to a dict
+                    main_batch_dict = main_batch.to_pandas().iloc[0].to_dict()
+                    caption_batch_dict = caption_batch.to_pandas(
+                    ).iloc[0].to_dict()
+                    dump_batch_dict = dump_batch.to_pandas().iloc[0].to_dict()
+                    assert caption_batch_dict['uttid'] == main_batch_dict[
+                        'uttid'] and caption_batch_dict['uttid'] == dump_batch_dict['uttid'], f"uttid not match {caption_batch_dict['uttid']} vs {main_batch_dict['uttid']}"
+                    main_batch_dict.update(caption_batch_dict)
+                    main_batch_dict.update(dump_batch_dict)
+                    yield main_batch_dict
+
+    def __iter_normal(self, epoch):
+        fs = get_filesystem(self.path)
+        with ParquetFile(self.path, filesystem=fs) as file:
+            # List all groups.
+            groups = list(range(file.num_row_groups))
+
+            # Partition groups if needed.
+            if self.partition == "group":
+                groups = get_portion_for_rank_and_worker(
+                    groups, self.force_partition)
+            elif self.partition == "dump":
+                groups = get_portion_for_worker_only(groups)
+
+            if self.shuffle:
+                # Shuffle groups
+                seed = (self.seed + epoch) if self.seed is not None else None
+                get_random_for_rank_and_worker(seed).shuffle(groups)
+
+            # Iteration over all samples from all row groups.
+            for group in groups:
+                for sample in file.iter_batches(
+                    batch_size=1, row_groups=[group], columns=self.columns,
+                    use_threads=False,
+                ):
+                    yield sample.to_pandas().iloc[0].to_dict()
+
+    def __iter__(self, epoch=0):
+        if self.plugin_caption_path != "":
+            return self.__iter_parallel(epoch)
+        else:
+            return self.__iter_normal(epoch)

dataset_code/sft_sftnews/offload/dataset_tool/parquet_dataset/parquet_utils.py

@@ -0,0 +1,142 @@
+import torch
+import random
+import importlib
+import contextlib
+import numpy as np
+
+from typing import Any, Dict, List, Optional
+from torch.utils.data import get_worker_info
+from omegaconf import DictConfig, ListConfig
+
+from .utils.partition_utils import partition_by_groups
+from .utils.distributed_utils import get_data_parallel_rank, get_data_parallel_world_size
+
+
+def get_worker_id() -> int:
+    """
+    Get the current dataloader worker id.
+    """
+    return get_worker_info().id if get_worker_info() is not None else 0
+
+
+def get_worker_count() -> int:
+    """
+    Get the total dataloader worker count.
+    """
+    return get_worker_info().num_workers if get_worker_info() is not None else 1
+
+
+def get_seed_for_rank_and_worker(seed: Optional[int]) -> Optional[int]:
+    """
+    Get seed for current rank and worker.
+    """
+    if seed is None:
+        return None
+    return seed + get_data_parallel_rank() * get_worker_count() + get_worker_id()
+
+
+def get_random_for_rank_and_worker(seed: Optional[int]) -> random.Random:
+    """
+    Get random.Random for the current rank and worker.
+    """
+    return random.Random(get_seed_for_rank_and_worker(seed))
+
+
+def get_random_for_all_ranks(seed: Optional[int]) -> random.Random:
+    """
+    Get random.Random that is the same for all ranks.
+    """
+    return random.Random(seed or 0)
+
+
+def get_portion_for_rank_and_worker(items: List[Any], force: bool = False, allow_empty: bool = False, resample: bool = False) -> List[Any]:
+    """
+    Get the portion of items for current rank and worker.
+    """
+    rank = get_data_parallel_rank()
+    world_size = get_data_parallel_world_size()
+    worker_id = get_worker_id()
+    worker_count = get_worker_count()
+    if resample:
+        return random.sample(items, len(items)//(world_size*worker_count))
+
+    if world_size * worker_count <= len(items):
+        # If there are enough items to be divided, we divide the items
+        items = partition_by_groups(items, world_size)[rank]
+        items = partition_by_groups(items, worker_count)[worker_id]
+    elif allow_empty:
+        if rank * worker_count + worker_id < len(items):
+            items = [items[rank * worker_count + worker_id]]
+        else:
+            items = []
+    elif not force:
+        # If not enough items to be divided, all ranks and workers shuffle it
+        # with different seed.
+        items = list(items)
+        get_random_for_rank_and_worker(0).shuffle(items)
+    else:
+        raise ValueError("Items not divisible by world_size * worker_count")
+    return items
+
+
+def get_portion_for_worker_only(items: List[Any]) -> List[Any]:
+    """
+    Get the portion of items for current worker.
+    """
+    worker_id = get_worker_id()
+    worker_count = get_worker_count()
+
+    items = partition_by_groups(items, worker_count)[worker_id]
+    return items
+
+
+@contextlib.contextmanager
+def local_seed(seed: Optional[int]):
+    """
+    Create a local context with seed is set, but exit back to the original random state.
+    If seed is None, do nothing.
+    """
+    if seed is not None:
+        random_state = random.getstate()
+        np_state = np.random.get_state()
+        torch_state = torch.get_rng_state()
+        random.seed(seed)
+        np.random.seed(seed)
+        torch.manual_seed(seed)
+        try:
+            yield
+        finally:
+            random.setstate(random_state)
+            np.random.set_state(np_state)
+            torch.set_rng_state(torch_state)
+    else:
+        yield
+
+
+def _as_list(datasets):
+    if isinstance(datasets, list):
+        return datasets
+    if isinstance(datasets, dict):
+        return [d for d in datasets.values() if d is not None]
+    raise ValueError
+
+
+def import_item(path: str, name: str) -> Any:
+    """
+    Import a python item. Example: import_item("path.to.file", "MyClass") -> MyClass
+    """
+    return getattr(importlib.import_module(path), name)
+
+
+def create_dataset(path: str, *args, **kwargs) -> Any:
+    """
+    Create a dataset. Requires the file to contain a "create_dataset" function.
+    """
+    return import_item(path, "create_dataset")(*args, **kwargs)
+
+
+def shift_seed(seed: Optional[int], shift: int) -> Optional[int]:
+    """
+    Shift the seed by a given amount. Or return None if seed is None.
+    """
+    return (seed + shift) if seed is not None else None

dataset_code/sft_sftnews/offload/dataset_tool/parquet_dataset/samplers/frame_sampler.py

@@ -0,0 +1,375 @@
+"""
+Frame samplers.
+"""
+
+import numpy as np
+
+from dataclasses import dataclass
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Literal, NamedTuple, Optional, Tuple, Union
+
+
+class FrameSamplerOutput(NamedTuple):
+    """
+    Return indices for frame decoding,
+    and optionally additional information to return to user.
+    """
+
+    indices: List[int]
+    additional_info: Dict[str, Any] = {}
+
+
+class FrameSampler(ABC):
+    """
+    Frame sampler base class.
+
+    Child class must implement __call__ method to return the decoding indices.
+    Or raise if the video cannot be sampled (e.g. too short, etc.)
+    """
+
+    @abstractmethod
+    def __call__(self, num_frames: int) -> FrameSamplerOutput:
+        raise NotImplementedError
+
+
+class AllFrameSampler(FrameSampler):
+    """
+    All frame sampler. Returns all frames in a video.
+    """
+
+    def __call__(self, num_frames: int) -> FrameSamplerOutput:
+        return FrameSamplerOutput(list(range(num_frames)))
+
+
+class AdaptiveFrameSampler(FrameSampler):
+    """
+    Adaptive frame sampler.
+
+    Arguments:
+        length: frame length to return.
+                For example, [5,10] denotes to always return 5 frames or 10 frames.
+                It will choose the longest length that fits the original video.
+                For example, if the video is 9 frames total, it will clip to 5 frames.
+        stride: frame skip.
+                For example, 1 denotes no skip. 2 denotes select every other frame. 3
+                denotes select every third frame. When a list is given, stride is randomly
+                chosen with even probability. However, user may set it to [1,1,2] to
+                denote 1 with 66% probability and 2 with 33% proability.
+        clip:   clip location.
+                    "center":   clip video at the center.
+                    "uniform":  clip video uniformly at random.
+        jitter: jitter to the location.
+                Only applicable when clip is "center".
+                The value is the stdev of the normal distribution to shift the index.
+    """
+
+    def __init__(
+        self,
+        lengths: Union[int, List[int]],
+        strides: Union[int, List[int]] = 1,
+        clip: Literal["center", "uniform"] = "uniform",
+        jitter: float = 0.0,
+    ):
+        lengths = [lengths] if isinstance(lengths, int) else lengths
+        strides = [strides] if isinstance(strides, int) else strides
+        assert len(lengths) > 0
+        assert len(strides) > 0
+        assert clip in ["center", "uniform"]
+        assert jitter >= 0
+        self.lengths = np.array(lengths)
+        self.strides = np.array(strides)
+        self.clip = clip
+        self.jitter = jitter
+
+    def __call__(
+        self,
+        num_frames: int,
+    ) -> FrameSamplerOutput:
+        # Choose stride.
+        # Drop strides that are too long for this video.
+        # Then randomly choose a valid stride.
+        valid_strides = np.any(num_frames // self.strides >=
+                               self.lengths.reshape(-1, 1), axis=0)
+        valid_strides = self.strides[valid_strides]
+        if valid_strides.size <= 0:
+            raise ValueError(f"Video is too short ({num_frames} frames).")
+        stride = np.random.choice(valid_strides)
+
+        # Choose length.
+        # Pick the max length that can fit the video under the current stride.
+        valid_lengths = self.lengths[num_frames // stride >= self.lengths]
+        length = np.max(valid_lengths)
+
+        # Choose start index.
+        min_start_index = 0
+        max_start_index = num_frames - 1 - stride * (length - 1)
+        mid_start_index = round((min_start_index + max_start_index) / 2)
+        jitter = round(np.random.normal(loc=0, scale=self.jitter))
+
+        if self.clip == "center":
+            start_index = mid_start_index + jitter
+        elif self.clip == "uniform":
+            start_index = np.random.randint(
+                min_start_index, max_start_index + 1)
+        else:
+            raise NotImplementedError
+
+        start_index = np.clip(start_index, min_start_index, max_start_index)
+
+        # Compute indices
+        indices = np.arange(start_index, start_index + length * stride, stride)
+
+        # Return indices and additional information to return to user.
+        return FrameSamplerOutput(
+            indices=indices.tolist(),
+            additional_info={
+                "stride": stride,
+                "start_frame": start_index,
+                "end_frame": start_index + length * stride,
+                "total_frames": num_frames,
+            },
+        )
+
+
+@dataclass
+class AdaptiveAdvancedFrameSamplerStrategy:
+    stride: int
+    stride_prob: float
+    frame_lengths: List[int]
+    frame_lengths_prob: Union[Literal["uniform", "harmonic"], List[float]]
+
+
+class AdaptiveAdvancedFrameSampler(FrameSampler):
+    """
+    Advanced adaptive frame sampler supports different frame lengths for different strides,
+    and supports probabilistic sampling of both the stride and the frame length.
+
+    strategies: A list of strategies to sample from.
+    clip:   clip location.
+            "center":   clip video at the center.
+            "uniform":  clip video uniformly at random.
+    jitter: jitter to the location.
+            Only applicable when clip is "center".
+            The value is the stdev of the normal distribution to shift the index.
+    """
+
+    def __init__(
+        self,
+        strategies: List[AdaptiveAdvancedFrameSamplerStrategy],
+        clip: Literal["center", "uniform","simple"] = "uniform",
+        jitter: float = 0.0,
+        aligned: bool = False,
+    ):
+        assert len(strategies) > 0, "Strategies must not be empty"
+        assert len({s.stride for s in strategies}) == len(
+            strategies), "Strides cannot duplicate."
+        assert clip in ["center", "uniform","simple"]
+        assert jitter >= 0
+        self.aligned = aligned
+        self.clip = clip
+        self.jitter = jitter
+        self.strides = []
+        self.strides_prob = []
+        self.frame_lengths = []
+        self.frame_lengths_prob = []
+
+        for strategy in sorted(strategies, key=lambda s: s.stride):
+            # Validate strides.
+            assert isinstance(
+                strategy.stride, int), "Stride must be an integer."
+            assert strategy.stride > 0, "Stride must be a positive integer."
+            self.strides.append(strategy.stride)
+
+            # Assign strides_prob.
+            assert isinstance(strategy.stride_prob, (int, float)
+                              ), "Stride prob is not int/float."
+            assert strategy.stride_prob >= 0, "Stride prob must be non-negative."
+            self.strides_prob.append(strategy.stride_prob)
+
+            # Assign frame lengths, sort by value.
+            assert len(
+                strategy.frame_lengths) > 0, "Frame lengths must not be empty."
+            frame_lengths = np.array(strategy.frame_lengths)
+            assert frame_lengths.dtype == int, "Frame lengths must be integers."
+            assert np.all(frame_lengths >
+                          0), "Frame lengths must be positive integers."
+            frame_lengths_sorted_idx = np.argsort(frame_lengths)
+            frame_lengths = frame_lengths[frame_lengths_sorted_idx]
+            self.frame_lengths.append(frame_lengths)
+
+            # Assign frame lengths prob, apply the sorting to prob as well.
+            if strategy.frame_lengths_prob == "uniform":
+                # e.g. [0.2, 0.2, 0.2, 0.2, 0.2]
+                frame_lengths_prob = np.full(
+                    len(frame_lengths), 1.0 / len(frame_lengths))
+            elif strategy.frame_lengths_prob == "harmonic":
+                # e.g. [0.2, 0.25, 0.33, 0.5, 1]
+                frame_lengths_prob = np.flip(
+                    1 / np.arange(1, len(frame_lengths) + 1))
+            elif isinstance(strategy.frame_lengths_prob, list):
+                frame_lengths_prob = np.array(strategy.frame_lengths_prob)
+                frame_lengths_prob = frame_lengths_prob[frame_lengths_sorted_idx]
+            else:
+                raise NotImplementedError
+            assert len(frame_lengths_prob) == len(
+                frame_lengths), "Frame lengths prob mismatch."
+            assert np.all(frame_lengths_prob >=
+                          0), "Frame lengths prob must not be negative."
+            assert frame_lengths_prob.sum() > 0, "Frame lengths prob must not be all zeros."
+            frame_lengths_prob /= frame_lengths_prob.sum()
+            self.frame_lengths_prob.append(frame_lengths_prob)
+
+        self.strides = np.array(self.strides)
+        self.strides_prob = np.array(self.strides_prob)
+        assert self.strides_prob.sum() > 0, "Strides prob must not be all zeros."
+        self.strides_prob /= self.strides_prob.sum()
+
+    def __call__(self, num_frames: int, frames_meta=None):
+        global_start_idx, global_end_idx = 0, num_frames
+        if self.aligned:
+            assert frames_meta is not None
+            global_start_idx = frames_meta['start_idxs']
+            global_end_idx = frames_meta['end_idxs']
+        num_frames = global_end_idx - global_start_idx
+
+        if self.clip != 'simple':
+            sample_result = adptive_sample_framelen_and_stride(
+                num_frames=num_frames,
+                strides=self.strides,
+                strides_prob=self.strides_prob,
+                frame_lengths=self.frame_lengths,
+                frame_lengths_prob=self.frame_lengths_prob,
+            )
+
+            stride = sample_result["stride"]
+            length = sample_result["frame_length"]
+        else:
+            stride = self.strides[0]
+            length = self.frame_lengths[0][0]
+
+        # Choose start index.
+        min_start_index = 0
+        max_start_index = num_frames - 1 - stride * (length - 1)
+        mid_start_index = round((min_start_index + max_start_index) / 2)
+        jitter = round(np.random.normal(loc=0, scale=self.jitter))
+
+        if self.clip == 'simple':
+            start_index = global_start_idx
+        ## can only load dump data, will fix further
+        # if self.clip == "center":
+        #     start_index = mid_start_index + jitter
+        # elif self.clip == "uniform":
+        #     start_index = np.random.randint(
+        #         min_start_index, max_start_index + 1)
+        # else:
+        #     raise NotImplementedError
+        # else:
+        #     start_index += global_start_idx
+        #     min_start_index += global_start_idx
+        #     max_start_index += global_start_idx
+        #     start_index = np.clip(start_index, min_start_index, max_start_index)
+
+        # Compute indices
+        indices = np.arange(start_index, start_index + length * stride, stride)
+
+        # Return indices and additional information to return to user.
+        return FrameSamplerOutput(
+            indices=indices.tolist(),
+            additional_info={
+                "stride": stride,
+                "start_frame": start_index,
+                "end_frame": start_index + length * stride,
+                "total_frames": num_frames,
+            },
+        )
+
+
+def normalize_probabilities(
+    items: np.ndarray,
+    probs: np.ndarray,
+    masks: np.ndarray,
+) -> Tuple[np.ndarray, np.ndarray]:
+    assert len(items), "Items must not be empty."
+    assert len(items) == len(masks) == len(probs), "Lengths must match."
+    assert isinstance(items, np.ndarray), "Items must be an np.ndarray."
+    assert isinstance(probs, np.ndarray), "Probs must be an np.ndarray."
+    assert isinstance(masks, np.ndarray), "Masks must be an np.ndarray."
+    assert masks.dtype == bool, "Masks must be boolean."
+    assert np.any(masks), "Masks must not be all False."
+    assert np.all(np.diff(masks.astype("int")) <=
+                  0), "Masks must not break monotonicity."
+
+    ret_items = items[masks]
+    ret_probs = probs[masks]
+
+    # Accumulate the probabilities of infeasible items to the last feasible one.
+    ret_probs[-1] += probs[~masks].sum()
+
+    return ret_items, ret_probs
+
+
+def adptive_sample_framelen_and_stride(
+    num_frames: int,
+    strides: np.ndarray,
+    strides_prob: np.ndarray,
+    frame_lengths: List[np.ndarray],
+    frame_lengths_prob: List[Optional[np.ndarray]],
+) -> Dict[str, Any]:
+    """Adaptively sample frame length and stride for a video.
+
+    Args:
+        num_frames: Number of frames in the current video.
+        strides: A list of strides.
+        strides_prob: The probability for each stride.
+        frame_lengths: The number of frames (sorted) to sample from at the current stride.
+            For example, `frame_length=10` at `stride=2` means that we need to have 20 frames.
+            When the number of frames to sample is infeasible, it will select the feasible frame
+            lengths and re-normalize the probability according to the feasible frames at hand.
+            For example, if `num_frames=10`, `frame_lengths[stride2]=[4, 5]`,
+            `frame_lengths[stride3]=[1, 3, 5]`, we can sample frame lengths 1, 2, and 5 at
+            `stride=2` (2, 4, and 10 frames) but only frame lengths 1, 3 at `stride=3`. In this
+            case, we will add the probability of `frame_length=5` at `stride=3` to `frame_length=3`
+            at `stride=3`, making it more likely to be selected.
+        frame_lengths_prob: The frame probabilities to sample from the corresponding frame lengths.
+            Defaults to None for uniform sampling.
+    Returns:
+        dictionary: A dictionary containing the selected frames and strides. if none is feasible,
+        it will raise an exception.
+    """
+    assert len(strides) == len(strides_prob) == len(
+        frame_lengths) == len(frame_lengths_prob)
+
+    # Prepare frame_lengths_mask for each stride.
+    frame_lengths_mask = [num_frames // s >=
+                          l for s, l in zip(strides, frame_lengths)]
+
+    # Prepare stride mask and prob.
+    strides_idxs = np.arange(len(strides))
+    strides_mask = np.array([np.any(mask) for mask in frame_lengths_mask])
+    assert np.any(strides_mask), (
+        f"Cannot sample frames={num_frames} "
+        + f"from strides={strides} and lengths={frame_lengths}"
+    )
+
+    # Drop infeasible strides and normalize probability.
+    strides_idxs, strides_prob = normalize_probabilities(
+        strides_idxs, strides_prob, strides_mask)
+
+    # Choose stride.
+    stride_idx = np.random.choice(strides_idxs, p=strides_prob)
+    stride = strides[stride_idx]
+
+    # Prepare frame_lengths mask and prob for the current stride.
+    lengths = frame_lengths[stride_idx]
+    lengths_mask = frame_lengths_mask[stride_idx]
+    lengths_prob = frame_lengths_prob[stride_idx]
+    if lengths_prob is None:
+        lengths_prob = np.full(len(lengths), 1.0 / len(lengths))
+
+    # Drop infeasible lengths and normalize probability.
+    lengths, lengths_prob = normalize_probabilities(
+        lengths, lengths_prob, lengths_mask)
+
+    # Choose frame length.
+    length = np.random.choice(lengths, p=lengths_prob)
+    return dict(stride=stride, frame_length=length)

dataset_code/sft_sftnews/offload/dataset_tool/parquet_dataset/samplers/text_sampler.py

@@ -0,0 +1,332 @@
+"""
+Text samplers.
+"""
+
+from bs4 import BeautifulSoup
+import urllib.parse as ul
+import html
+import ftfy
+import re
+import numpy as np
+
+from abc import ABC, abstractmethod
+from typing import Dict, List, NamedTuple, Union
+
+
+class TextSamplerOutput(NamedTuple):
+    """
+    Return keys for text embedding,
+    and optionally additional information to return to user.
+    """
+
+    keys: Union[str, List[str]]
+
+
+class TextSampler(ABC):
+    """
+    Text sampler base class.
+
+    Child class must implement __call__ method to return the embedding keys.
+    Or raise if the text cannot be sampled (key does not exist.)
+    """
+
+    @abstractmethod
+    def __call__(self, text: Dict[str, str]) -> TextSamplerOutput:
+        raise NotImplementedError
+
+
+class TextAllSampler(TextSampler):
+    """
+    All text sampler. Returns all texts.
+
+    e.g.
+    text_sampler:
+      type: all
+    """
+
+    def __init__(
+        self,
+        all: List[str] = None,
+        **kwargs,
+    ):
+        self.all = all
+
+    def __call__(self, text: Dict[str, str]) -> TextSamplerOutput:
+        assert len(text) > 0, "The input text does not exist."
+
+        # Get keys.
+        keys = list(text.keys())
+
+        if self.all is not None:
+            keys = [key for key in self.all if key in keys]
+            assert len(
+                keys) > 0, f"No valid text sample found under keys: {text.keys()}."
+
+        return TextSamplerOutput(keys=keys)
+
+
+class TextFrequencySampler(TextSampler):
+    """
+    Sample text based on frequency.
+
+    e.g.
+    text_sampler:
+      type: frequency
+      frequency:
+        no_title_qwen_caption_en_v2_text: 0.9
+        no_title_qwen_caption_en_text: 0.9
+        origin_caption: 0.1
+
+        # support regular expression
+        -----
+        .+qwen_caption_en.+: 0.95
+        origin_caption: 0.05
+        -----
+        .+caption_qwen_recaption_cn_long_2_82_text: 0.9
+        .+caption_qwen_recaption_cn_2_95_text: 0.9
+        origin_caption: 0.1
+        -----
+    """
+
+    def __init__(
+        self,
+        frequency: Dict[str, float] = {},
+    ):
+        self.frequency = frequency
+        # Get regular expression.
+        self.patterns = (
+            {k: re.compile(k) for k in frequency.keys()
+             } if frequency is not None else None
+        )
+
+    def __call__(self, text: Dict[str, str]) -> TextSamplerOutput:
+
+        assert len(text) > 0, "The input text does not exist."
+
+        # Get keys.
+        keys = list(text.keys())
+
+        # Get weights.
+        if self.frequency is None or len(self.frequency) == 0:
+            weights = np.array([1.0] * len(keys))
+        else:
+            matchs = {k: (False, "") for k in text.keys()}
+            counter = {k: 0 for k in self.frequency.keys()}
+            for k in keys:
+                for pstr, pat in self.patterns.items():
+                    if pat.match(k) is not None:
+                        matchs[k] = (True, pstr)
+                        counter[pstr] += 1
+                        break
+            weights = np.array(
+                [
+                    self.frequency[matchs[k][1]] /
+                    counter[matchs[k][1]] if matchs[k][0] else 0.0
+                    for k in keys
+                ]
+            )
+        weights_sum = weights.sum()
+        assert weights_sum > 0, f"No valid text sample found under keys: {keys}."
+        weights /= weights_sum
+
+        # Sample key.
+        keys = str(np.random.choice(keys, p=weights))
+        return TextSamplerOutput(keys=keys)
+
+
+class TextPrioritySampler(TextSampler):
+    """
+    Sample text based on priority.
+
+    e.g.
+    text_sampler:
+      type: priority
+      priority:
+        - no_title_qwen_caption_en_v2_text
+        - no_title_qwen_caption_en_text
+        - origin_caption
+    """
+
+    def __init__(
+        self,
+        priority: List[str] = [],
+    ):
+        self.priority = priority
+
+    def __call__(self, text: Dict[str, str]) -> TextSamplerOutput:
+
+        assert len(text) > 0, "The input text does not exist."
+
+        # Get keys.
+        keys = list(text.keys())
+
+        # Get priorities.
+        priorities = [key for key in self.priority if key in keys]
+
+        # Select key.
+        if priorities:
+            keys = priorities[0]
+        else:
+            keys = str(np.random.choice(keys))
+
+        return TextSamplerOutput(keys=keys)
+
+
+"""
+Text cleaner. Copied from DeepFloyd IF.
+(https://github.com/deep-floyd/IF/blob/develop/deepfloyd_if/modules/t5.py#L125)
+"""
+
+
+class TextCleaner:
+    """
+    Clear up a caption with strange/improper contents
+    """
+
+    bad_punct_regex = re.compile(
+        r"["
+        + "#®•©™&@·º½¾¿¡§~"
+        + r"\)"
+        + r"\("
+        + r"\]"
+        + r"\["
+        + r"\}"
+        + r"\{"
+        + r"\|"
+        + "\\"
+        + r"\/"
+        + r"\*"
+        + r"]{1,}"
+    )
+
+    def __call__(self, text):
+        # The exact text cleaning as was in the training stage:
+        text = self.clean_caption(text)
+        text = self.clean_caption(text)
+        return text
+
+    @staticmethod
+    def basic_clean(text):
+        text = ftfy.fix_text(text)
+        text = html.unescape(html.unescape(text))
+        return text.strip()
+
+    def clean_caption(self, caption):
+        caption = str(caption)
+        caption = ul.unquote_plus(caption)
+        caption = caption.strip().lower()
+        caption = re.sub("<person>", "person", caption)
+        caption = re.sub("<br>", " ", caption)
+        # urls:
+        caption = re.sub(
+            r"\b((?:https?:(?:\/{1,3}|[a-zA-Z0-9%])|[a-zA-Z0-9.\-]+[.](?:com|co|ru|net|org|edu|gov|it)[\w/-]*\b\/?(?!@)))",  # noqa: E501
+            "",
+            caption,
+        )  # regex for urls
+        caption = re.sub(
+            r"\b((?:www:(?:\/{1,3}|[a-zA-Z0-9%])|[a-zA-Z0-9.\-]+[.](?:com|co|ru|net|org|edu|gov|it)[\w/-]*\b\/?(?!@)))",  # noqa: E501
+            "",
+            caption,
+        )  # regex for urls
+        # html:
+        caption = BeautifulSoup(caption, features="html.parser").text
+
+        # @<nickname>
+        caption = re.sub(r"@[\w\d]+\b", "", caption)
+
+        # 31C0—31EF CJK Strokes
+        # 31F0—31FF Katakana Phonetic Extensions
+        # 3200—32FF Enclosed CJK Letters and Months
+        # 3300—33FF CJK Compatibility
+        # 3400—4DBF CJK Unified Ideographs Extension A
+        # 4DC0—4DFF Yijing Hexagram Symbols
+        # 4E00—9FFF CJK Unified Ideographs
+        caption = re.sub(r"[\u31c0-\u31ef]+", "", caption)
+        caption = re.sub(r"[\u31f0-\u31ff]+", "", caption)
+        caption = re.sub(r"[\u3200-\u32ff]+", "", caption)
+        caption = re.sub(r"[\u3300-\u33ff]+", "", caption)
+        caption = re.sub(r"[\u3400-\u4dbf]+", "", caption)
+        caption = re.sub(r"[\u4dc0-\u4dff]+", "", caption)
+        caption = re.sub(r"[\u4e00-\u9fff]+", "", caption)
+        #######################################################
+
+        # все виды тире / all types of dash --> "-"
+        caption = re.sub(
+            r"[\u002D\u058A\u05BE\u1400\u1806\u2010-\u2015\u2E17\u2E1A\u2E3A\u2E3B\u2E40\u301C\u3030\u30A0\uFE31\uFE32\uFE58\uFE63\uFF0D]+",  # noqa: E501
+            # noqa
+            "-",
+            caption,
+        )
+
+        # кавычки к одному стандарту
+        caption = re.sub(r"[`´«»“”¨]", '"', caption)
+        caption = re.sub(r"[‘’]", "'", caption)
+
+        # &quot;
+        caption = re.sub(r"&quot;?", "", caption)
+        # &amp
+        caption = re.sub(r"&amp", "", caption)
+
+        # ip adresses:
+        caption = re.sub(r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}", " ", caption)
+
+        # article ids:
+        caption = re.sub(r"\d:\d\d\s+$", "", caption)
+
+        # \n
+        caption = re.sub(r"\\n", " ", caption)
+
+        # "#123"
+        caption = re.sub(r"#\d{1,3}\b", "", caption)
+        # "#12345.."
+        caption = re.sub(r"#\d{5,}\b", "", caption)
+        # "123456.."
+        caption = re.sub(r"\b\d{6,}\b", "", caption)
+        # filenames:
+        caption = re.sub(
+            r"[\S]+\.(?:png|jpg|jpeg|bmp|webp|eps|pdf|apk|mp4)", "", caption)
+
+        #
+        caption = re.sub(r"[\"\']{2,}", r'"', caption)  # """AUSVERKAUFT"""
+        caption = re.sub(r"[\.]{2,}", r" ", caption)  # """AUSVERKAUFT"""
+
+        # ***AUSVERKAUFT***, #AUSVERKAUFT
+        caption = re.sub(self.bad_punct_regex, r" ", caption)
+        caption = re.sub(r"\s+\.\s+", r" ", caption)  # " . "
+
+        # this-is-my-cute-cat / this_is_my_cute_cat
+        regex2 = re.compile(r"(?:\-|\_)")
+        if len(re.findall(regex2, caption)) > 3:
+            caption = re.sub(regex2, " ", caption)
+
+        caption = self.basic_clean(caption)
+
+        caption = re.sub(r"\b[a-zA-Z]{1,3}\d{3,15}\b", "", caption)  # jc6640
+        caption = re.sub(r"\b[a-zA-Z]+\d+[a-zA-Z]+\b", "", caption)  # jc6640vc
+        caption = re.sub(r"\b\d+[a-zA-Z]+\d+\b", "", caption)  # 6640vc231
+
+        caption = re.sub(r"(worldwide\s+)?(free\s+)?shipping", "", caption)
+        caption = re.sub(r"(free\s)?download(\sfree)?", "", caption)
+        caption = re.sub(r"\bclick\b\s(?:for|on)\s\w+", "", caption)
+        caption = re.sub(
+            r"\b(?:png|jpg|jpeg|bmp|webp|eps|pdf|apk|mp4)(\simage[s]?)?", "", caption)
+        caption = re.sub(r"\bpage\s+\d+\b", "", caption)
+
+        # j2d1a2a...
+        caption = re.sub(
+            r"\b\d*[a-zA-Z]+\d+[a-zA-Z]+\d+[a-zA-Z\d]*\b", r" ", caption)
+
+        caption = re.sub(r"\b\d+\.?\d*[xх×]\d+\.?\d*\b", "", caption)
+
+        caption = re.sub(r"\b\s+\:\s+", r": ", caption)
+        caption = re.sub(r"(\D[,\./])\b", r"\1 ", caption)
+        caption = re.sub(r"\s+", " ", caption)
+
+        caption.strip()
+
+        caption = re.sub(r"^[\"\']([\w\W]+)[\"\']$", r"\1", caption)
+        caption = re.sub(r"^[\'\_,\-\:;]", r"", caption)
+        caption = re.sub(r"[\'\_,\-\:\-\+]$", r"", caption)
+        caption = re.sub(r"^\.\S+$", "", caption)
+
+        return caption.strip()

dataset_code/sft_sftnews/offload/dataset_tool/parquet_dataset/samplers/utils.py

@@ -0,0 +1,42 @@
+from omegaconf import DictConfig, OmegaConf
+
+from .text_sampler import (TextAllSampler,
+                           TextFrequencySampler,
+                           TextPrioritySampler,
+                           TextSampler,
+                           )
+from .frame_sampler import (AdaptiveAdvancedFrameSampler,
+                            AdaptiveAdvancedFrameSamplerStrategy,
+                            AdaptiveFrameSampler,
+                            AllFrameSampler,
+                            FrameSampler,
+                            )
+
+TEXT_SAMPLER_TYPES = {
+    "all": TextAllSampler,
+    "frequency": TextFrequencySampler,
+    "priority": TextPrioritySampler,
+}
+
+
+def create_text_sampler(config: dict) -> TextSampler:
+    config = OmegaConf.to_object(config)
+    sampler_type = config.pop("type")
+    return TEXT_SAMPLER_TYPES[sampler_type](**config)
+
+
+FRAME_SAMPLER_TYPES = {
+    "all": AllFrameSampler,
+    "adaptive": AdaptiveFrameSampler,
+    "adaptive_advanced": AdaptiveAdvancedFrameSampler,
+}
+
+
+def create_frame_sampler(config: dict) -> FrameSampler:
+    config = OmegaConf.to_object(config)
+    sampler_type = config.pop("type")
+    if sampler_type == "adaptive_advanced":
+        config["strategies"] = [
+            AdaptiveAdvancedFrameSamplerStrategy(**s) for s in config["strategies"]
+        ]
+    return FRAME_SAMPLER_TYPES[sampler_type](**config)

dataset_code/sft_sftnews/offload/dataset_tool/parquet_dataset/tos_client.py

@@ -0,0 +1,192 @@
+import logging
+import os
+import yaml
+import hashlib
+import traceback
+from typing import Any, Union, List, Optional
+import bytedtos
+import io
+import decord
+import torch
+from pyarrow import fs
+
+def hdfs_read(file_path) -> bytes:
+    fp = str(file_path)
+    filesystem = resolve_fs(fp)
+
+    with filesystem.open_input_stream(fp) as f:
+        content = f.readall()
+    return content
+
+def sha256_hashs(b: bytes, nbytes=32, bit_len=128) -> bytes:
+    m = hashlib.sha256()
+    m.update(b)
+    mb = m.digest()
+    bb = mb[:nbytes] 
+    truncated_hashs = bb[: bit_len // 8]
+    return truncated_hashs.hex().lower()
+
+def retry(func, retry=3):
+    if retry == 0:
+        return func
+
+    def wrapper(*args, **kwargs):
+        for i in range(retry):
+            error = ''
+            try:
+                return func(*args, **kwargs)
+            except KeyboardInterrupt:
+                raise KeyboardInterrupt
+            except:
+                print(f"In {__file__}, retry {i + 1} times!")
+                error = traceback.format_exc()
+        raise Exception(f"Traceback: {error}")
+
+    return wrapper
+
+
+def resolve_fs(paths: Union[str, list[str]]) -> fs.FileSystem:
+    _p: str = paths  # type: ignore
+    if isinstance(paths, list):
+        _p = paths[0]
+    _p = "/".join(_p.split("/")[:3])
+    filesystem, _ = fs._resolve_filesystem_and_path(_p)
+
+    return filesystem
+
+
+
+class BaseClient:
+    def __init__(self, retry=0, **kwargs):
+        self.retry = retry
+
+    def __call__(self, keys: Union[str, List[str]], hashs: Optional[Union[str, List[str]]]=None) -> Union[bytes, List[bytes]]:
+        """
+        Read bytes from remote data source.
+        Args:
+            keys (str or list[str]): tos keys or hdfs uri or etc.
+            hashs (str or list[str]): hashs of the data.
+        Returns:
+            bytes (or list[bytes]]): bytes read from remote data source.
+        """
+        if isinstance(keys, str):
+            assert hashs is None or isinstance(hashs, str)
+            keys = [keys]
+            hashs = [hashs] if hashs is not None else None
+            return_list = False
+        else:
+            return_list = True
+        
+        if hashs is not None:
+            bytes_get = retry(self.get_bytes_and_check, retry=3)(keys, hashs)
+        else:
+            bytes_get = retry(self.get_bytes, retry=self.retry)(keys)
+
+        if return_list:
+            return bytes_get
+        else:
+            return bytes_get[0]
+
+    def get_bytes_and_check(self, keys: List[bytes], hashs: List[bytes]) -> List[bytes]:
+        bytes_get = self.get_bytes(keys)
+        for k, b, h in zip(keys, bytes_get, hashs):
+            if sha256_hashs(b) != h:
+                raise Exception(f"hashs check failed on keyss {k}, {sha256_hashs(b)} != {h}!")
+        return bytes_get
+
+    def get_bytes(self, keys: List[bytes]) -> List[bytes]:
+        """
+        Read bytes from remote data source.
+        Args:
+            keyss: tos keys or hdfs uri or etc.
+        Returns:
+            bytes: bytes read from remote data source.
+        """
+        raise NotImplementedError
+
+class TosClient(BaseClient):
+    def __init__(
+        self,
+        ak,
+        bucket,
+        idc,
+        timeout=10,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.tos_client = bytedtos.Client(bucket, ak, timeout=timeout, idc=idc)
+
+    # Input => toskeys
+    def get_bytes(self, keys: List[bytes]) -> List[bytes]:
+        """
+        Read bytes from tos keys.
+        Args:
+            keys (str or list[str]): tos keys.
+        Returns:
+            bytes (or list[bytes]]): bytes read from tos.
+        """
+        return [self.tos_client.get_object(keys).data for keys in keys]
+
+class NebuTosClient(TosClient):
+    default_config = {
+        "nebudata-us": "hdfs://harunava/home/byte_icaip_nebudata/proj/nebudata/conf/nebuconfig_va_20240925.yaml",
+        "nebudata-sg": "hdfs://harunasg/home/byte_icaip_nebudata_sg/proj/nebudata/conf/nebuconfig_sg_20240925.yaml",  # Default
+    }
+
+    def __init__(
+        self,
+        ref_tos_bucket: Union[str, None] = None,
+        idc: Union[str, None] = None,
+        **kwargs,
+    ):
+        logging.info(f"NebuTos config: {ref_tos_bucket=} {idc=}")
+        if idc is None:
+            idc = os.environ.get("RUNTIME_IDC_NAME", "my2")
+        
+        if ref_tos_bucket is not None:
+            assert ref_tos_bucket in self.default_config, f"Unknow tos_bucket {ref_tos_bucket}, please use one of {self.default_config.keyss()}."
+            nebuconfig_file = self.default_config.get(ref_tos_bucket)
+        else:
+            arnold_base_dir = os.environ.get("ARNOLD_BASE_DIR", "hdfs://harunasg")
+            for ref_tos_bucket, nebuconfig_file in self.default_config.items():
+                if arnold_base_dir in nebuconfig_file:
+                    break
+
+        nebuconfig = yaml.safe_load(hdfs_read(nebuconfig_file).decode("utf-8"))
+        default_access_keys = nebuconfig['tos_user_access_key']
+        tos_ak = os.environ.get("TOS_USER_ACCESS_key", default_access_keys)
+
+        super().__init__(tos_ak, ref_tos_bucket, idc, **kwargs)
+
+
+if __name__ == "__main__":
+    client = NebuTosClient(ref_tos_bucket="nebudata-sg", idc="my2")
+    # toskey = 'cas/596ccf6d8de5d16e0ca5a91c0610d9bd'
+    toskey = 'cas/0c862903f94897a08bde81ee10104c48'
+    results = [client(toskey, hashs=toskey.split('cas/')[-1])]
+    # with open('output_video.mp4', 'wb') as f:
+    #     f.write(results[0])
+    # np_array = np.frombuffer(results[0], dtype=np.uint8)
+    file_io = io.BytesIO(results[0])
+    reader = decord.VideoReader(file_io, ctx=decord.cpu(0))
+    video_length = len(reader)
+    # sampler = FrameSamplerCollection(data_configs['samplers'])
+    # video_idxs, structure = self.sampler(video_length, params)
+    # frames_idxs = copy.deepcopy(video_idxs)
+    # in_range_len = len(video_idxs)
+    # out_range_idxs = self.add_out_range_sample(
+    #     video_idxs, video_length, params)
+    # video_idxs = video_idxs + out_range_idxs
+    # video_idxs_array = np.array(video_idxs)
+    # video_idxs_valid_mask = video_idxs_array >= 0
+    # valid_indices = video_idxs_array[video_idxs_valid_mask]
+    valid_indices = list(range(121))
+    frames_batch = reader.get_batch(valid_indices).asnumpy()
+    frames_tensor = torch.from_numpy(frames_batch).float()
+    frames_tensor = (frames_tensor / 127.5) - 1
+    frames_tensor = frames_tensor.permute(0, 3, 1, 2)
+    del reader
+
+# 'clip_toskey': 'cas/596ccf6d8de5d16e0ca5a91c0610d9bd'
+# 'clip_tosurl': 'https://tosv.byted.org/obj/nebudata-sg/cas/596ccf6d8de5d16e0ca5a91c0610d9bd'
+# 'clip_url': 'https://tosv-sg.tiktok-row.org/obj/nebudata-sg/cas/596ccf6d8de5d16e0ca5a91c0610d9bd'

dataset_code/sft_sftnews/offload/dataset_tool/parquet_dataset/utils/distributed_utils.py

@@ -0,0 +1,149 @@
+"""
+Distributed basic functions.
+"""
+
+import os
+import torch
+import torch.distributed as dist
+
+from typing import Optional
+from torch.nn.parallel import DistributedDataParallel
+
+_DATA_PARALLEL_GROUP = None
+_SEQUENCE_PARALLEL_GROUP = None
+_SEQUENCE_PARALLEL_CPU_GROUP = None
+
+
+def get_global_rank() -> int:
+    """
+    Get the global rank, the global index of the GPU.
+    """
+    return int(os.environ.get("RANK", "0"))
+
+
+def get_local_rank() -> int:
+    """
+    Get the local rank, the local index of the GPU.
+    """
+    return int(os.environ.get("LOCAL_RANK", "0"))
+
+
+def get_world_size() -> int:
+    """
+    Get the world size, the total amount of GPUs.
+    """
+    return int(os.environ.get("WORLD_SIZE", "1"))
+
+
+def get_device() -> torch.device:
+    """
+    Get current rank device.
+    """
+    return torch.device("cuda", get_local_rank())
+
+
+def barrier_if_distributed(*args, **kwargs):
+    """
+    Synchronizes all processes if under distributed context.
+    """
+    if dist.is_initialized():
+        return dist.barrier(*args, **kwargs)
+
+
+def init_torch(cudnn_benchmark=True):
+    """
+    Common PyTorch initialization configuration.
+    """
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
+    torch.backends.cudnn.benchmark = cudnn_benchmark
+    torch.cuda.set_device(get_local_rank())
+    dist.init_process_group(
+        backend="nccl",
+        rank=get_global_rank(),
+        world_size=get_world_size(),
+    )
+
+
+def convert_to_ddp(module: torch.nn.Module, **kwargs) -> DistributedDataParallel:
+    return DistributedDataParallel(
+        module=module,
+        device_ids=[get_local_rank()],
+        output_device=get_local_rank(),
+        **kwargs,
+    )
+
+
+def get_data_parallel_group() -> Optional[dist.ProcessGroup]:
+    """
+    Get data parallel process group.
+    """
+    return _DATA_PARALLEL_GROUP
+
+
+def get_sequence_parallel_group() -> Optional[dist.ProcessGroup]:
+    """
+    Get sequence parallel process group.
+    """
+    return _SEQUENCE_PARALLEL_GROUP
+
+
+def get_sequence_parallel_cpu_group() -> Optional[dist.ProcessGroup]:
+    """
+    Get sequence parallel CPU process group.
+    """
+    return _SEQUENCE_PARALLEL_CPU_GROUP
+
+
+def get_data_parallel_rank() -> int:
+    """
+    Get data parallel rank.
+    """
+    group = get_data_parallel_group()
+    return dist.get_rank(group) if group else get_global_rank()
+
+
+def get_data_parallel_world_size() -> int:
+    """
+    Get data parallel world size.
+    """
+    group = get_data_parallel_group()
+    return dist.get_world_size(group) if group else get_world_size()
+
+
+def get_sequence_parallel_rank() -> int:
+    """
+    Get sequence parallel rank.
+    """
+    group = get_sequence_parallel_group()
+    return dist.get_rank(group) if group else 0
+
+
+def get_sequence_parallel_world_size() -> int:
+    """
+    Get sequence parallel world size.
+    """
+    group = get_sequence_parallel_group()
+    return dist.get_world_size(group) if group else 1
+
+
+def init_sequence_parallel(sequence_parallel_size: int):
+    """
+    Initialize sequence parallel.
+    """
+    global _DATA_PARALLEL_GROUP
+    global _SEQUENCE_PARALLEL_GROUP
+    global _SEQUENCE_PARALLEL_CPU_GROUP
+    assert dist.is_initialized()
+    world_size = dist.get_world_size()
+    rank = dist.get_rank()
+    data_parallel_size = world_size // sequence_parallel_size
+    for i in range(data_parallel_size):
+        start_rank = i * sequence_parallel_size
+        end_rank = (i + 1) * sequence_parallel_size
+        ranks = range(start_rank, end_rank)
+        group = dist.new_group(ranks)
+        cpu_group = dist.new_group(ranks, backend="gloo")
+        if rank in ranks:
+            _SEQUENCE_PARALLEL_GROUP = group
+            _SEQUENCE_PARALLEL_CPU_GROUP = cpu_group