| from pprint import pformat |
| import random |
| import numpy as np |
| import time |
| import os |
| from utils.tsv_io import TSVDataset |
| from utils.tsv_io import load_list_file |
| from utils.tsv_io import get_tsv_lineidx, get_tsv_lineidx_8b |
| from utils.tsv_io import TSVFile |
| from utils.common import exclusive_open_to_read |
| import os.path as op |
| import logging |
| import torch.multiprocessing as mp |
| import math |
| from utils.common import list_to_dict |
| import torch |
| import torch.distributed as dist |
| from torch.utils.data.sampler import Sampler |
| from utils.common import get_mpi_rank, get_mpi_size, get_mpi_local_size, get_mpi_local_rank |
| from utils.common import print_frame_info |
| from azfuse import File as QDFile |
|
|
|
|
| def find_start_tsv_idx(num_each_tsv_file, node_offset): |
| x = node_offset |
| start_tsv_idx = None |
| for tsv_idx, tsv_size in enumerate(num_each_tsv_file): |
| x -= tsv_size |
| if x < 0: |
| start_tsv_idx = tsv_idx |
| break |
| assert start_tsv_idx is not None, (node_offset, sum(num_each_tsv_file)) |
| return start_tsv_idx |
|
|
| def construct_groups_by_chunk(num_each_tsv_file, offset, num, chunk_size): |
| s = 0 |
| end_idx_each_tsv_file = [] |
| for x in num_each_tsv_file: |
| end_idx_each_tsv_file.append(x + s) |
| s += x |
| curr_idx = offset |
| num = min(num, end_idx_each_tsv_file[-1] - offset) |
| tsv_groups = [] |
| while curr_idx < offset + num: |
| curr_end_idx = curr_idx + chunk_size |
| curr_end_idx = min(curr_end_idx, offset + num) |
| g = {'start_idx': curr_idx, 'end_idx': curr_end_idx} |
| tsv_idx1 = find_start_tsv_idx(num_each_tsv_file, curr_idx) |
| tsv_idx2 = find_start_tsv_idx(num_each_tsv_file, curr_end_idx - 1) |
| g['all_tsv_idx'] = list(range(tsv_idx1, tsv_idx2 + 1)) |
| tsv_groups.append(g) |
| curr_idx = curr_end_idx |
| return tsv_groups |
|
|
| def construct_tsv_groups(node_offset, num_on_node, start_tsv_idx, |
| num_each_tsv_file): |
| tsv_groups = [] |
| start_idx = node_offset |
| tsv_idx = start_tsv_idx |
| end_idx_each_tsv_file = [] |
| s = 0 |
| for x in num_each_tsv_file: |
| end_idx_each_tsv_file.append(x + s) |
| s += x |
| while True: |
| g = {'start_idx': start_idx, 'tsv_idx': tsv_idx} |
| |
| |
| |
| if end_idx_each_tsv_file[tsv_idx] < num_on_node + node_offset: |
| g['end_idx'] = end_idx_each_tsv_file[tsv_idx] |
| tsv_groups.append(g) |
| tsv_idx += 1 |
| start_idx = g['end_idx'] |
| else: |
| g['end_idx'] = num_on_node + node_offset |
| tsv_groups.append(g) |
| break |
| return tsv_groups |
|
|
| class ScaleNodeSplitBySplitSampler(Sampler): |
| def __init__(self, dataset, shuffle=False, random_seed=6, skip=0, |
| prepare_t_versions=[], |
| overwrite_dataset_len=None, |
| disable_prepare=False, |
| start_offset=0, |
| prepare_queue_len=0, |
| queue=None, |
| ): |
| self.dataset = dataset |
| self.shuffle = shuffle |
| self.random_seed = random_seed |
|
|
| self.world_size = get_mpi_size() |
| self.local_size = get_mpi_local_size() |
| self.node_size = self.world_size // self.local_size |
| self.rank = get_mpi_rank() |
| self.node_idx = self.rank // self.local_size |
| self.local_rank = get_mpi_local_rank() |
| |
| self.overwrite_dataset_len = overwrite_dataset_len |
| self.prepare_queue_len = prepare_queue_len |
|
|
| |
| self.prepare = None |
| self.prepare_t_versions = prepare_t_versions |
| self.enable_prepare = not disable_prepare |
| self.skip = skip |
| self.start_offset = start_offset |
| self.queue = queue |
| assert not (start_offset > 0 and overwrite_dataset_len is not None) |
|
|
| def __iter__(self): |
| if self.skip > 0: |
| logging.info('we will skip {}'.format(self.skip)) |
| if self.overwrite_dataset_len: |
| |
| |
| dataset_len = self.overwrite_dataset_len |
| else: |
| dataset_len = len(self.dataset) |
| num = dataset_len - self.start_offset |
| logging.info('num sample = {}'.format(num)) |
| num_on_node = (num + self.node_size - 1) // self.node_size |
| node_offset = num_on_node * self.node_idx + self.start_offset |
| num_on_node = min(num_on_node, dataset_len - node_offset) |
| |
| |
| |
| num_each_tsv_file = self.dataset.get_num_each_tsv() |
|
|
| |
| start_tsv_idx = find_start_tsv_idx(num_each_tsv_file, node_offset) |
| |
| tsv_groups = construct_tsv_groups(node_offset, num_on_node, start_tsv_idx, |
| num_each_tsv_file) |
|
|
| if get_mpi_local_rank() == 0 and self.enable_prepare and self.prepare is None: |
| self.prepare = PrepareData(self.dataset, |
| prepare_t_versions=self.prepare_t_versions, |
| |
| queue=self.queue, |
| ) |
|
|
| local_random = random.Random() |
| local_random.seed(self.random_seed) |
| |
| num_tsv_cache = 8 |
| local_rank_offset = self.local_rank |
| while True: |
| for idx_group, group in enumerate(tsv_groups): |
| start_idx = group['start_idx'] |
| end_idx = group['end_idx'] |
| curr_idx = range(start_idx, end_idx) |
| if self.shuffle: |
| curr_idx = list(curr_idx) |
| local_random.shuffle(curr_idx) |
| if self.prepare and self.skip <= 0: |
| for i in range(num_tsv_cache): |
| g = tsv_groups[(idx_group + 1 + i) % len(tsv_groups)] |
| self.prepare.prepare(g['tsv_idx']) |
| while local_rank_offset < len(curr_idx): |
| if self.skip <= 0: |
| yield curr_idx[local_rank_offset] |
| else: |
| self.skip -= 1 |
| local_rank_offset += self.local_size |
| local_rank_offset -= len(curr_idx) |
|
|
| |
| |
|
|
| class ScaleNodeSplitSampler(Sampler): |
| def __init__(self, dataset, shuffle=False, random_seed=6, skip=0, |
| prepare_t_versions=[], |
| overwrite_dataset_len=None, |
| start_offset=0, |
| prepare_queue_len=0, |
| queue=None, |
| ): |
| self.dataset = dataset |
| self.shuffle = shuffle |
| self.random_seed = random_seed |
|
|
| self.world_size = get_mpi_size() |
| self.local_size = get_mpi_local_size() |
| self.node_size = self.world_size // self.local_size |
| self.rank = get_mpi_rank() |
| self.node_idx = self.rank // self.local_size |
| self.local_rank = get_mpi_local_rank() |
| |
| self.overwrite_dataset_len = overwrite_dataset_len |
|
|
| |
| self.prepare = None |
| self.prepare_t_versions = prepare_t_versions |
| self.enable_prepare = True |
| self.skip = skip |
| self.queue = queue |
| self.start_offset = start_offset |
| self.prepare_queue_len = prepare_queue_len |
|
|
| def get_shufle_idx(self, n): |
| g = torch.Generator() |
| g.manual_seed(self.random_seed) |
| random_idx = torch.randperm(n, generator=g) |
| self.random_seed += 99 |
| return random_idx |
|
|
| def __iter__(self): |
| if self.skip > 0: |
| logging.info('we will skip {}'.format(self.skip)) |
| idx_end_at = 0 |
| if self.overwrite_dataset_len: |
| |
| |
| num = self.overwrite_dataset_len |
| idx_end_at = num |
| assert self.start_offset == 0 |
| else: |
| idx_end_at = len(self.dataset) |
| num = idx_end_at - self.start_offset |
| logging.info('num sample = {}'.format(num)) |
| num_on_node = (num + self.node_size - 1) // self.node_size |
| node_offset = num_on_node * self.node_idx + self.start_offset |
| chunk_size = 1048576 |
| chunk_size = chunk_size // self.local_size * self.local_size |
| num_each_tsv_file = self.dataset.get_num_each_tsv() |
| tsv_groups = construct_groups_by_chunk(num_each_tsv_file, node_offset, num_on_node, chunk_size) |
| for t in tsv_groups[:-1]: |
| assert t['start_idx'] < idx_end_at |
| assert t['end_idx'] < idx_end_at |
| t = tsv_groups[-1] |
| assert t['start_idx'] < idx_end_at |
| t['end_idx'] = min(idx_end_at, t['end_idx']) |
| if get_mpi_local_rank() == 0 and self.prepare is None: |
| self.prepare = PrepareData(self.dataset, |
| prepare_t_versions=self.prepare_t_versions, |
| |
| queue=self.queue, |
| ) |
| num_cache_group = 8 |
| warmed_up = False |
| while True: |
| for idx_chunk, tsv_group in enumerate(tsv_groups): |
| chunk_start = tsv_group['start_idx'] |
| chunk_end = tsv_group['end_idx'] |
|
|
| chunk_idxs = list(range(chunk_start + self.local_rank, chunk_end, self.local_size)) |
| all_sub_idx = self.get_shufle_idx(len(chunk_idxs)) if self.shuffle else range(len(chunk_idxs)) |
|
|
| prepare_idx = int(random.random() * len(all_sub_idx)) |
| prepare_idx = min(len(all_sub_idx) - 1, prepare_idx) |
| logging.info(f'will prepare at {prepare_idx}/{len(all_sub_idx)}') |
|
|
| for _idx, j in enumerate(all_sub_idx): |
| if self.prepare and self.skip <= 0 and (not warmed_up or _idx == prepare_idx) and self.enable_prepare: |
| if not warmed_up: |
| for cache_idx in range(num_cache_group): |
| self.prepare.prepare(tsv_groups[(idx_chunk + cache_idx)%len(tsv_groups)]['all_tsv_idx']) |
| warmed_up = True |
| else: |
| cache_idx = num_cache_group - 1 |
| self.prepare.prepare(tsv_groups[(idx_chunk + cache_idx)%len(tsv_groups)]['all_tsv_idx']) |
| i = chunk_idxs[j] |
| if self.skip <= 0: |
| yield i |
| else: |
| self.skip -= 1 |
|
|
| |
| |
|
|
| class NodeSplitSampler(Sampler): |
| def __init__(self, dataset, shuffle, random_seed, first_epoch_skip_shuffle=False, |
| prepare_t_versions=[], |
| skip=0, |
| ): |
| self.dataset = dataset |
| self.shuffle = shuffle |
| self.random_seed = random_seed |
|
|
| self.world_size = get_mpi_size() |
| self.local_size = get_mpi_local_size() |
| self.node_size = self.world_size // self.local_size |
| self.rank = get_mpi_rank() |
| self.node_idx = self.rank // self.local_size |
| self.local_rank = get_mpi_local_rank() |
| self.next_epoch_skip_shuffle = first_epoch_skip_shuffle |
|
|
| |
| self.prepare = None |
| self.prepare_t_versions = prepare_t_versions |
| self.skip = skip |
|
|
| def get_index_on_node(self): |
| |
| |
| idx_split = self.dataset.get_composite_source_idx() |
| idx_split = list(enumerate(idx_split)) |
| idx_split = torch.tensor(idx_split) |
| if self.shuffle: |
| random_idx = self.get_shufle_idx(len(idx_split)) |
| idx_split = idx_split[random_idx] |
| max_split = idx_split[:, 1].max() + 1 |
| priority = self.get_shufle_idx(max_split) |
| sort_idx = torch.argsort(priority[idx_split[:, 1]]) |
| idx_split = idx_split[sort_idx] |
| num_idx_on_node = (len(idx_split) + self.node_size - 1) // self.node_size |
| offset = num_idx_on_node * self.node_idx |
| offset_end = offset + num_idx_on_node |
| offset_end = min(offset_end, len(idx_split)) |
| if self.shuffle and self.next_epoch_skip_shuffle: |
| unique_split_index = ordered_unique(idx_split[offset:offset_end, 1].tolist()) |
| logging.info(unique_split_index) |
| if get_mpi_local_rank() == 0: |
| self.prepare = PrepareData(self.dataset, |
| prepare_t_versions=self.prepare_t_versions, |
| ) |
| self.prepare.prepare(list(unique_split_index)) |
| return idx_split[offset:offset_end, 0] |
|
|
| def get_shufle_idx(self, n): |
| g = torch.Generator() |
| g.manual_seed(self.random_seed) |
| random_idx = torch.randperm(n, generator=g) |
| self.random_seed += 99 |
| return random_idx |
|
|
| def get_index_on_rank(self, idx_on_node): |
| if self.shuffle: |
| if not self.next_epoch_skip_shuffle: |
| curr_idx_on_node = idx_on_node[self.get_shufle_idx(len(idx_on_node))] |
| else: |
| curr_idx_on_node = idx_on_node |
| self.next_epoch_skip_shuffle = False |
| else: |
| curr_idx_on_node = idx_on_node |
| idx_rank_size = (len(curr_idx_on_node) + self.local_size - 1) // self.local_size |
| offset = idx_rank_size * self.local_rank |
| offset_end = offset + idx_rank_size |
| offset_end = min(offset_end, len(curr_idx_on_node)) |
| curr_idx_on_node = curr_idx_on_node.tolist() |
| for i in range(offset, offset_end): |
| yield curr_idx_on_node[i] |
|
|
| def __iter__(self): |
| self.curr_idx = 0 |
| idx_on_node = self.get_index_on_node() |
| if self.skip > 0: |
| logging.info('we will skip {}'.format(self.skip)) |
| while True: |
| for i in self.get_index_on_rank(idx_on_node): |
| if self.skip <= 0: |
| yield i |
| else: |
| self.skip -= 1 |
|
|
| def __len__(self): |
| return 100000 |
| |
| |
|
|
| class RankSplitSampler(Sampler): |
| def __init__(self, dataset, shuffle, random_seed): |
| self.dataset = dataset |
| self.shuffle = shuffle |
| self.random_seed = random_seed |
|
|
| self.world_size = get_mpi_size() |
| self.rank = get_mpi_rank() |
|
|
| def get_index(self): |
| source_list = self.dataset.get_composite_source_idx() |
| idx_split = list(enumerate(source_list)) |
| idx_split = torch.tensor(idx_split) |
| if self.shuffle: |
| g = torch.Generator() |
| g.manual_seed(self.random_seed) |
| random_idx = torch.randperm(len(idx_split), generator=g) |
| idx_split = idx_split[random_idx] |
| sort_idx = torch.argsort(idx_split[:, 1]) |
| idx_split = idx_split[sort_idx] |
| rank_size = (len(idx_split) + self.world_size - 1) // self.world_size |
| offset = rank_size * self.rank |
| offset_end = offset + rank_size |
| offset_end = min(offset_end, len(idx_split)) |
| return idx_split[offset:offset_end, 0].tolist() |
|
|
| def __iter__(self): |
| self.curr_idx = 0 |
| all_idx = self.get_index() |
| while True: |
| if self.curr_idx >= len(all_idx): |
| self.curr_idx -= len(all_idx) |
| yield all_idx[self.curr_idx] |
| self.curr_idx += 1 |
|
|
| |
| |
|
|
|
|
| class PrepareDataFileQueue(object): |
| def __init__(self, folder): |
| self.folder = folder |
| from utils.common import ensure_remove_dir, ensure_directory |
| logging.info('cleaning the folder of {}'.format(folder)) |
| ensure_remove_dir(folder) |
| ensure_directory(folder) |
| self.iter = 0 |
| self.curr_num_fnames = [] |
|
|
| def put(self, ls): |
| fname = op.join(self.folder, str(self.iter)) |
| self.iter += 1 |
| if isinstance(ls, str): |
| ls = [ls] |
| from utils.tsv_io import write_to_file |
| write_to_file('\n'.join(ls), fname) |
|
|
| def get(self): |
| |
| import glob |
| while True: |
| if len(self.curr_num_fnames) == 0: |
| fnames = glob.glob(op.join(self.folder, '*')) |
| if len(fnames) == 0: |
| time.sleep(10) |
| continue |
| basenames = [op.basename(f) for f in fnames] |
| num_fnames = [(int(b), f) for b, f in zip(basenames, fnames) if 'tmp' not in b] |
| |
| num_fnames = sorted(num_fnames, key=lambda x: x[0]) |
| self.curr_num_fnames.extend(num_fnames) |
| fn = self.curr_num_fnames[0][1] |
| ls = load_list_file(fn) |
| from utils.common import ensure_remove_file |
| ensure_remove_file(fn) |
| del self.curr_num_fnames[0] |
| return ls |
|
|
| def create_prepare_tsv_file_process(max_len=0): |
| use_thread = True |
| if use_thread: |
| import threading |
| import queue |
| prepare_queue = queue.Queue() |
| p = threading.Thread( |
| target=prepare_tsv_file_process, args=(prepare_queue, max_len), |
| daemon=True, |
| ) |
| p.start() |
| else: |
| prepare_queue = mp.Queue() |
| p = mp.Process( |
| target=prepare_tsv_file_process, args=(prepare_queue, max_len), |
| daemon=True, |
| ) |
| p.start() |
| return p, prepare_queue |
|
|
| def prepare_tsv_file_process(queue, max_len=0): |
| if os.environ.get('QD_TSV_USE_FUSE'): |
| if int(os.environ['QD_TSV_USE_FUSE']): |
| ftype = 'fuser' |
| else: |
| ftype = 'blobfuse' |
| else: |
| ftype = 'blobfuse' |
|
|
| if ftype == 'fuser': |
| from utils.cloud_storage import create_cloud_fuse |
| fuser = create_cloud_fuse() |
| logging.info('ftype = {}'.format(ftype)) |
|
|
| prepared = [] |
|
|
| while True: |
| start = time.time() |
| fnames = queue.get() |
| end = time.time() |
| if (end - start) > 5: |
| logging.info('waiting {} to get a new tsv to prepare'.format( |
| end - start)) |
| curr_fs = [] |
| for fname in fnames: |
| curr_fs.append(fname) |
| if fname.endswith('.tsv'): |
| lineidx8b = get_tsv_lineidx_8b(fname) |
| curr_fs.append(lineidx8b) |
|
|
| def unprepare(info): |
| logging.info('unprepare {}'.format(info['fnames'])) |
| if ftype == 'blobfuse': |
| for f in info['fps']: |
| f.close() |
| logging.info('unprepared {}'.format(info['fnames'])) |
| else: |
| to_remove = [] |
| for f in info['fnames']: |
| if all(f not in fs['fnames'] for fs in prepared): |
| to_remove.append(f) |
| fuser.ensure_del_cache(f) |
| logging.info('unprepared {}'.format(to_remove)) |
|
|
| sames = [i for i, p in enumerate(prepared) |
| if all(f in p['fnames'] for f in curr_fs)] |
| if len(sames) > 0 and ftype == 'blobfuse': |
| |
| i = sames[0] |
| p = prepared[i] |
| del prepared[i] |
| prepared.append(p) |
| logging.info('no need to prepare {} as it prepared'.format( |
| curr_fs |
| )) |
| continue |
|
|
| while max_len > 0 and len(prepared) >= max_len: |
| unprepare(prepared.pop(0)) |
|
|
| logging.info('prepare {}'.format(curr_fs)) |
| start = time.time() |
| if ftype == 'blobfuse': |
| info = { |
| 'fnames': curr_fs, |
| 'fps': [exclusive_open_to_read(x) for x in curr_fs] |
| } |
| prepared.append(info) |
| else: |
| info = { |
| 'fnames': curr_fs |
| } |
| if len(info['fnames']) > 0: |
| prepared.append(info) |
| fuser.ensure_cache(curr_fs, touch_cache_if_exist=True) |
| logging.info('use {}s, prepared {}; max len = {}; curr len = {}; all prepared = {}'.format( |
| time.time() - start, |
| curr_fs, |
| max_len, |
| len(prepared), |
| ';'.join([','.join(p['fnames']) for p in prepared]), |
| )) |
| time.sleep(random.random() * 5) |
|
|
| def ordered_unique(sequence): |
| seen = set() |
| return [x for x in sequence if not (x in seen or seen.add(x))] |
|
|
| class PrepareData(object): |
| fuser = None |
| def __init__(self, dataset, prepare_t_versions=[], |
| fixed_samples_in_node=False, |
| disable_prepare=None, |
| disable_garbage_collection=False, |
| prepare_queue_len=0, |
| queue=None, |
| ): |
| self.prepare_files = None |
| |
| self.dataset = dataset |
| self.prepare_t_versions = prepare_t_versions |
| |
| self.disable_prepare = disable_prepare or (queue is None) |
| |
| self.queue = queue |
| |
|
|
| def get_composite_source_files(self): |
| data = self.dataset.dataset.data |
| split = self.dataset.dataset.split |
| dataset = TSVDataset(data) |
| result = [] |
| for t, version in self.prepare_t_versions: |
| tsv = dataset.get_data(split, t, version) |
| if QDFile.isfile(tsv): |
| result.append([(tsv,0)]) |
| else: |
| x_tsv = dataset.get_data(split + 'X', t, version) |
| assert op.isfile(x_tsv) |
| result.append(TSVFile(x_tsv)) |
| return result |
|
|
| def prepare(self, split): |
| if self.disable_prepare: |
| return |
| self.ensure_init_prepare() |
| q = self.prepare_queue |
| if isinstance(split, (list, tuple)): |
| tsv_files = [ps[s][0] for s in split for ps in self.prepare_files] |
| else: |
| tsv_files = [ps[split][0] for ps in self.prepare_files] |
| logging.info('send to prepare: {}'.format(','.join(tsv_files))) |
| q.put(tsv_files) |
|
|
| def prepare_all(self, tsv_idx_start=0): |
| if self.disable_prepare: |
| return |
| self.ensure_init_prepare() |
| q = self.prepare_queue |
| tsv_files = [] |
| for ps in self.prepare_files: |
| for i in range(tsv_idx_start, len(ps)): |
| tsv_files.append(ps[i][0]) |
| assert len(tsv_files) > 0, 'maybe bug?' |
| q.put(tsv_files) |
|
|
| def ensure_init_prepare(self): |
| if self.prepare_files is None: |
| self.prepare_files = self.get_composite_source_files() |
| assert self.queue is not None |
| self.prepare_queue = self.queue |
|
|
| class PrepareData_old(object): |
| fuser = None |
| def __init__(self, dataset, prepare_t_versions=[], |
| fixed_samples_in_node=False, |
| disable_prepare=None, |
| disable_garbage_collection=False, |
| prepare_queue_len=0, |
| queue=None, |
| ): |
| self.prepare_files = None |
| |
| self.dataset = dataset |
| self.prepare_t_versions = prepare_t_versions |
| |
| self.disable_prepare = disable_prepare or (queue is None) |
| |
| self.queue = queue |
| |
|
|
| def get_composite_source_files(self): |
| data = self.dataset.dataset.data |
| split = self.dataset.dataset.split |
| dataset = TSVDataset(data) |
| result = [] |
| for t, version in self.prepare_t_versions: |
| tsv = dataset.get_data(split, t, version) |
| if QDFile.isfile(tsv): |
| result.append([tsv]) |
| else: |
| x_tsv = dataset.get_data(split + 'X', t, version) |
| assert op.isfile(x_tsv) |
| result.append(load_list_file(x_tsv)) |
| return result |
|
|
| def prepare(self, split): |
| if self.disable_prepare: |
| return |
| self.ensure_init_prepare() |
| q = self.prepare_queue |
| |
| |
| |
| if isinstance(split, (list, tuple)): |
| tsv_files = [ps[s] for s in split for ps in self.prepare_files] |
| else: |
| tsv_files = [ps[split] for ps in self.prepare_files] |
| logging.info('send to prepare: {}'.format(','.join(tsv_files))) |
| q.put(tsv_files) |
|
|
| def prepare_all(self, tsv_idx_start=0): |
| if self.disable_prepare: |
| return |
| self.ensure_init_prepare() |
| q = self.prepare_queue |
| tsv_files = [] |
| for ps in self.prepare_files: |
| tsv_files.extend(ps[tsv_idx_start:]) |
| assert len(tsv_files) > 0, 'maybe bug?' |
| q.put(tsv_files) |
|
|
| def ensure_init_prepare(self): |
| if self.prepare_files is None: |
| self.prepare_files = self.get_composite_source_files() |
| assert self.queue is not None |
| self.prepare_queue = self.queue |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| def create_download_worker(queue, max_len=0): |
| p = mp.Process( |
| target=prepare_tsv_file_process, args=(queue, max_len), |
| daemon=True, |
| ) |
| p.start() |
| return p |
|
|
| class SplitBySplitSampler(Sampler): |
| def __init__(self, dataset, group_size=1, shuffle=True, |
| fixed_samples_in_node=False, |
| random_seed=9, |
| skip=0, |
| prepare_t_versions=[], |
| disable_prepare=None, |
| ): |
| print_frame_info() |
| self.dataset = dataset |
| self.group_size = group_size |
| self.random_seed = random_seed |
| self.shuffle = shuffle |
|
|
| self.rank = get_mpi_rank() |
| self.local_rank = get_mpi_local_rank() |
| self.world_size = get_mpi_size() |
| self.local_size = get_mpi_local_size() |
|
|
| self.node_size = self.world_size // self.local_size |
| self.node_idx = self.rank // self.local_size |
|
|
| self.shuffle_group_process = None |
|
|
| self.prepare_process = None |
| self.prepare_queue = None |
| self.prepare_files = None |
| |
| |
| self.prepare_t_versions = prepare_t_versions |
| self.sub_process_create_shuffle = False |
| self._idx_split = None |
| self.iter_shuffle_group = None |
|
|
| self.curr_group_buffers = None |
| self.next_group_index = 0 |
| self.cache_group_index_on_node = None |
|
|
| self.disable_prepare = disable_prepare |
| self.get_group_process = None |
| self.fixed_samples_in_node = fixed_samples_in_node |
| self.skip = skip |
|
|
| def get_composite_source_idx(self): |
| return self.dataset.get_composite_source_idx() |
|
|
| def get_composite_source_files(self): |
| data = self.dataset.dataset.data |
| split = self.dataset.dataset.split |
| dataset = TSVDataset(data) |
| result = [] |
| for t, version in self.prepare_t_versions: |
| tsv = dataset.get_data(split, t, version) |
| if op.isfile(tsv): |
| result.append([tsv]) |
| else: |
| x_tsv = dataset.get_data(split + 'X', t, version) |
| assert op.isfile(x_tsv) |
| result.append(load_list_file(x_tsv)) |
| return result |
|
|
| def load_idx_split(self): |
| logging.info('loading source list') |
| source_list = self.get_composite_source_idx() |
| logging.info('loaded source list') |
| idx_split = list(enumerate(source_list)) |
| idx_split = torch.tensor(idx_split) |
| return idx_split |
|
|
| @property |
| def idx_split(self): |
| if self._idx_split is None: |
| self._idx_split = self.load_idx_split() |
| |
| return self._idx_split |
|
|
| def get_shufle_idx(self, n): |
| g = torch.Generator() |
| g.manual_seed(self.random_seed) |
| random_idx = torch.randperm(n, generator=g) |
| self.random_seed += 99 |
| return random_idx |
|
|
| def get_group_index_on_node_random(self): |
| idx_split = self.idx_split |
|
|
| max_split = idx_split[:, 1].max() + 1 |
| priority = self.get_shufle_idx(max_split) |
|
|
| random_idx = self.get_shufle_idx(len(idx_split)) |
| idx_split = idx_split[random_idx] |
|
|
| idx_split = torch.cat([idx_split[idx_split[:, 1] == p] for p in priority]) |
|
|
| num_idx_on_node = (len(idx_split) + self.node_size - 1) // self.node_size |
| offset = num_idx_on_node * self.node_idx |
| offset_end = offset + num_idx_on_node |
| offset_end = min(offset_end, len(idx_split)) |
| idx_split = idx_split[offset:offset_end] |
|
|
| unique_split_index = ordered_unique(idx_split[:, 1].tolist()) |
| logging.info(unique_split_index) |
| result = [ |
| { |
| 'idx_in_group': idx_split[idx_split[:, 1] == s][:, 0].tolist(), |
| 'split_in_group': s, |
| } |
| for s in unique_split_index |
| ] |
| return result |
|
|
| def get_group_index_on_node(self): |
| if self.shuffle and not self.fixed_samples_in_node: |
| return self.get_group_index_on_node_random() |
| elif self.shuffle and self.fixed_samples_in_node: |
| if self.cache_group_index_on_node is None: |
| self.cache_group_index_on_node = self.get_group_index_on_node_random() |
| idx = self.get_shufle_idx(len(self.cache_group_index_on_node)) |
| group_in_node = [self.cache_group_index_on_node[i] for i in idx] |
| for g in group_in_node: |
| idx = self.get_shufle_idx(len(g['idx_in_group'])) |
| g['idx_in_group'] = [g['idx_in_group'][i] for i in idx] |
| return group_in_node |
| else: |
| if self.cache_group_index_on_node is None: |
| self.cache_group_index_on_node = self.get_group_index_on_node_random() |
| return self.cache_group_index_on_node |
|
|
| def get_next_group_index_on_node(self): |
| if self.curr_group_buffers is None: |
| self.curr_group_buffers = self.get_group_index_on_node() |
| self.next_group_index = 0 |
| if self.next_group_index >= len(self.curr_group_buffers): |
| self.curr_group_buffers = self.get_group_index_on_node() |
| self.next_group_index = 0 |
| g = self.curr_group_buffers[self.next_group_index] |
| self.next_group_index += 1 |
| return g |
|
|
| def get_group_thread(self, q): |
| while True: |
| if q.qsize() < 8: |
| g = self.get_next_group_index_on_node() |
| q.put(g) |
| else: |
| time.sleep(1) |
|
|
| def __iter__(self): |
| use_thread_to_get_group = True |
| if not use_thread_to_get_group: |
| assert self.skip == 0, 'not supported' |
| group_buffers = [self.get_next_group_index_on_node() |
| for _ in range(4)] |
| if self.local_rank == 0: |
| for g in group_buffers: |
| self.prepare(g['split_in_group']) |
| assert len(group_buffers) > 0 |
| idx = self.local_rank |
| while True: |
| while idx >= len(group_buffers[0]['idx_in_group']): |
| idx -= len(group_buffers[0]['idx_in_group']) |
| group_buffers.pop(0) |
| new_g = self.get_next_group_index_on_node() |
| if self.local_rank == 0: |
| self.prepare(new_g['split_in_group']) |
| group_buffers.append(new_g) |
| r = group_buffers[0]['idx_in_group'][idx] |
| yield r |
| idx += self.local_size |
| else: |
| self.ensure_init_get_group_thread() |
| group_buffers = [self.get_group_queue.get() |
| for _ in range(4)] |
| if self.local_rank == 0: |
| for g in group_buffers: |
| if self.skip <= 0: |
| self.prepare(g['split_in_group']) |
| assert len(group_buffers) > 0 |
| idx = self.local_rank |
| while True: |
| while idx >= len(group_buffers[0]['idx_in_group']): |
| idx -= len(group_buffers[0]['idx_in_group']) |
| group_buffers.pop(0) |
| start = time.time() |
| new_g = self.get_group_queue.get() |
| cost = time.time() - start |
| logging.info('time to get group index on node: {}'.format(cost)) |
| if self.local_rank == 0 and self.skip <= 0: |
| self.prepare(new_g['split_in_group']) |
| group_buffers.append(new_g) |
| r = group_buffers[0]['idx_in_group'][idx] |
| if self.skip <= 0: |
| yield r |
| else: |
| self.skip -= 1 |
| idx += self.local_size |
|
|
| def ensure_init_get_group_thread(self): |
| if self.get_group_process is None: |
| import threading |
| import queue |
| q = queue.Queue() |
| t = threading.Thread( |
| target=self.get_group_thread, args=(q,), |
| daemon=True, |
| ) |
| t.start() |
| self.get_group_process = t |
| self.get_group_queue = q |
|
|
| def ensure_init_prepare(self): |
| if self.prepare_files is None: |
| self.prepare_files = self.get_composite_source_files() |
| if self.prepare_process is None: |
| max_len = 8 if not self.fixed_samples_in_node else 0 |
| p, prepare_queue = create_prepare_tsv_file_process( |
| max_len=max_len) |
| self.prepare_process = p |
| self.prepare_queue = prepare_queue |
|
|
| def prepare(self, split): |
| if self.disable_prepare: |
| return |
| self.ensure_init_prepare() |
| q = self.prepare_queue |
| size = q.qsize() |
| if size > 100: |
| logging.info('prepare queue is too long {}'.format(size)) |
| q.put([ps[split] for ps in self.prepare_files]) |
|
|
| |
| |
|
|
| class AttachIterationNumberBatchSampler(object): |
| def __init__(self, batch_sampler, start_iter, num_iters, |
| gradient_accumulate=1): |
| self.batch_sampler = batch_sampler |
| self.curr_iter = start_iter |
| self.max_iter = num_iters |
| self.gradient_accumulate = gradient_accumulate |
|
|
| def __getattr__(self, att): |
| return getattr(self.batch_sampler, att) |
|
|
| def __iter__(self): |
| |
| |
| |
| for idx_batch, batch in enumerate(self.batch_sampler): |
| batch = [{'iteration': self.curr_iter, |
| 'idx': i, |
| 'max_iter': self.max_iter} for i in batch] |
| yield batch |
| if (idx_batch + 1) % self.gradient_accumulate == 0: |
| self.curr_iter += 1 |
|
|
| def __len__(self): |
| return len(self.batch_sampler) |
|
|
| class OrderedSplitSampler(Sampler): |
| def __init__(self, data_length): |
| curr_rank = get_mpi_rank() |
| world_size = get_mpi_size() |
| rank_size = (data_length + world_size - 1) // world_size |
| start = rank_size * curr_rank |
| end = start + rank_size |
| assert start >= 0 and start <= data_length |
| if curr_rank < world_size - 1: |
| assert end >= 0 and end <= data_length |
| end = min(end, data_length) |
| self.start = start |
| self.end = end |
|
|
| def __iter__(self): |
| return iter(range(self.start, self.end)) |
|
|
| def __len__(self): |
| return self.end - self.start |
|
|
| class BatchSampler(Sampler): |
| r"""Wraps another sampler to yield a mini-batch of indices. |
| |
| Args: |
| sampler (Sampler): Base sampler. |
| batch_size (int): Size of mini-batch. |
| drop_last (bool): If ``True``, the sampler will drop the last batch if |
| its size would be less than ``batch_size`` |
| |
| Example: |
| >>> list(BatchSampler(SequentialSampler(range(10)), batch_size=3, drop_last=False)) |
| [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]] |
| >>> list(BatchSampler(SequentialSampler(range(10)), batch_size=3, drop_last=True)) |
| [[0, 1, 2], [3, 4, 5], [6, 7, 8]] |
| """ |
|
|
| def __init__(self, sampler, batch_size, drop_last): |
| if not isinstance(sampler, Sampler): |
| raise ValueError("sampler should be an instance of " |
| "torch.utils.data.Sampler, but got sampler={}" |
| .format(sampler)) |
| if not isinstance(drop_last, bool): |
| raise ValueError("drop_last should be a boolean value, but got " |
| "drop_last={}".format(drop_last)) |
| self.sampler = sampler |
| self.batch_size = batch_size |
| self.drop_last = drop_last |
|
|
| def __iter__(self): |
| batch = [] |
| for idx in self.sampler: |
| batch.append(idx) |
| if len(batch) == self.batch_size: |
| yield batch |
| batch = [] |
| if len(batch) > 0 and not self.drop_last: |
| yield batch |
|
|
| def __len__(self): |
| if self.drop_last: |
| return len(self.sampler) // self.batch_size |
| else: |
| return (len(self.sampler) + self.batch_size - 1) // self.batch_size |
|
|
| class IterationBasedBatchSampler(BatchSampler): |
| """ |
| Wraps a BatchSampler, resampling from it until |
| a specified number of iterations have been sampled |
| """ |
|
|
| def __init__(self, batch_sampler, num_iterations, start_iter=0, |
| ): |
| self.batch_sampler = batch_sampler |
| self.num_iterations = num_iterations |
| self.start_iter = start_iter |
|
|
| if hasattr(batch_sampler, 'batch_size'): |
| self.batch_size = batch_sampler.batch_size |
|
|
| if hasattr(batch_sampler, 'drop_last'): |
| self.drop_last = batch_sampler.drop_last |
|
|
| def __iter__(self): |
| iteration = self.start_iter |
| while iteration <= self.num_iterations: |
| |
| |
| |
| if hasattr(self.batch_sampler.sampler, "set_epoch"): |
| self.batch_sampler.sampler.set_epoch(iteration) |
| for batch in self.batch_sampler: |
| iteration += 1 |
| if iteration > self.num_iterations: |
| break |
| yield batch |
|
|
| def __len__(self): |
| return self.num_iterations |
|
|
|
|
| class DynamicBatchSampler(BatchSampler): |
| def __init__(self, sampler, get_batch_size, start_iter=0): |
| self.sampler = sampler |
| self.get_batch_size = get_batch_size |
| self.start_iter = start_iter |
|
|
| def __iter__(self): |
| batch = [] |
| batch_size = None |
| curr_iter = self.start_iter |
| for idx in self.sampler: |
| batch.append(idx) |
| if batch_size is None: |
| batch_size = self.get_batch_size(curr_iter) |
| if len(batch) == batch_size: |
| yield batch |
| batch_size = None |
| curr_iter += 1 |
| batch = [] |
|
|
| class InfinityDistributedSampler(Sampler): |
| def __init__(self, dataset, num_replicas=None, rank=None, shuffle=True, |
| skip=0, |
| start_offset=0, |
| prepare_t_versions=[], |
| queue=None, |
| ): |
| if num_replicas is None: |
| if not dist.is_available(): |
| raise RuntimeError("Requires distributed package to be available") |
| from utils.common import get_mpi_size |
| num_replicas = get_mpi_size() |
| if rank is None: |
| if not dist.is_available(): |
| raise RuntimeError("Requires distributed package to be available") |
| from utils.common import get_mpi_rank |
| rank = get_mpi_rank() |
| self.dataset = dataset |
| self.num_replicas = num_replicas |
| self.rank = rank |
| self.epoch = 0 |
| self.start_offset = start_offset |
| self.num_samples = int(math.ceil(self.get_effective_dataset_len() * 1.0 / self.num_replicas)) |
| length_divisible = num_replicas |
| if length_divisible > 1: |
| import logging |
| logging.info('before making divisible = {}'.format(self.num_samples)) |
| self.num_samples = ((self.num_samples + length_divisible - 1) // |
| length_divisible) * length_divisible |
| logging.info('adjust to = {}'.format(self.num_samples)) |
| self.total_size = self.num_samples * self.num_replicas |
| self.shuffle = shuffle |
| self.skip = skip |
| self.num_passed = 0 |
| |
| self.queue = queue |
| self.prepare = None |
| self.prepare_t_versions = prepare_t_versions |
|
|
| def get_effective_dataset_len(self): |
| return len(self.dataset) - self.start_offset |
|
|
| def state_dict(self): |
| return {'num_passed': self.num_passed} |
|
|
| def load_state_dict(self, info): |
| if info is not None: |
| self.skip = info['num_passed'] |
|
|
| def __iter__(self): |
| self.num_passed = 0 |
| if get_mpi_local_rank() == 0 and self.prepare is None: |
| self.prepare = PrepareData(self.dataset, |
| prepare_t_versions=self.prepare_t_versions, |
| queue=self.queue, |
| ) |
| if self.start_offset == 0: |
| self.prepare.prepare_all() |
| else: |
| num_each_tsv_file = self.dataset.get_num_each_tsv() |
| start_tsv_idx = find_start_tsv_idx(num_each_tsv_file, self.start_offset) |
| self.prepare.prepare_all(start_tsv_idx) |
| while True: |
| if self.shuffle: |
| |
| g = torch.Generator() |
| g.manual_seed(self.epoch) |
| self.epoch += 1 |
| indices = torch.randperm(self.get_effective_dataset_len(), generator=g).tolist() |
| else: |
| indices = torch.arange(self.get_effective_dataset_len()).tolist() |
|
|
| while len(indices) < self.total_size: |
| if 2 * len(indices) < self.total_size: |
| indices += indices |
| else: |
| indices += indices[: (self.total_size - len(indices))] |
| assert len(indices) == self.total_size |
|
|
| |
| offset = self.num_samples * self.rank |
| indices = indices[offset : offset + self.num_samples] |
| assert len(indices) == self.num_samples |
| for i in indices: |
| if self.skip > 0: |
| self.skip -= 1 |
| else: |
| yield i + self.start_offset |
| self.num_passed += 1 |
|
|
| def __len__(self): |
| raise ValueError('invalid') |
|
|
|
|
| class DistributedSampler(Sampler): |
| |
| def __init__(self, dataset, num_replicas=None, rank=None, shuffle=True): |
| if num_replicas is None: |
| if not dist.is_available(): |
| raise RuntimeError("Requires distributed package to be available") |
| from utils.common import get_mpi_size |
| num_replicas = get_mpi_size() |
| if rank is None: |
| if not dist.is_available(): |
| raise RuntimeError("Requires distributed package to be available") |
| from utils.common import get_mpi_rank |
| rank = get_mpi_rank() |
| self.dataset = dataset |
| self.num_replicas = num_replicas |
| self.rank = rank |
| self.epoch = 0 |
| self.num_samples = int(math.ceil(len(self.dataset) * 1.0 / self.num_replicas)) |
| length_divisible = num_replicas |
| if length_divisible > 1: |
| logging.info('before making divisible = {}'.format(self.num_samples)) |
| self.num_samples = ((self.num_samples + length_divisible - 1) // |
| length_divisible) * length_divisible |
| logging.info('adjust to = {}'.format(self.num_samples)) |
| self.total_size = self.num_samples * self.num_replicas |
| self.shuffle = shuffle |
| logging.info('force shuffle = False') |
| self.shuffle = False |
|
|
| def __iter__(self): |
| if self.shuffle: |
| |
| g = torch.Generator() |
| g.manual_seed(self.epoch) |
| indices = torch.randperm(len(self.dataset), generator=g).tolist() |
| else: |
| indices = torch.arange(len(self.dataset)).tolist() |
|
|
| |
| while len(indices) < self.total_size: |
| if 2 * len(indices) <= self.total_size: |
| indices += indices |
| else: |
| indices += indices[: (self.total_size - len(indices))] |
| indices += indices[: (self.total_size - len(indices))] |
| assert len(indices) == self.total_size |
|
|
| |
| offset = self.num_samples * self.rank |
| indices = indices[offset : offset + self.num_samples] |
| assert len(indices) == self.num_samples |
|
|
| return iter(indices) |
|
|
| def __len__(self): |
| return self.num_samples |
|
|
| def set_epoch(self, epoch): |
| self.epoch = epoch |
|
|
| class ScaleNodeSplitVLPlusScaleNodeSplitLBatchSampler(Sampler): |
| def __init__(self, |
| dataset, |
| one_fwd_batch_size_per_gpu, |
| one_fwd_batch_size_per_gpu_text_only, |
| gradient_accumulate, |
| max_iter, |
| train_shuffle, |
| vl_data_rate, |
| prepare_t_versions=[], |
| vl_queue=None, |
| l_queue=None, |
| skip=0, |
| ): |
| print_frame_info() |
| self.dataset = dataset |
| self.one_fwd_batch_size_per_gpu = [ |
| one_fwd_batch_size_per_gpu, |
| one_fwd_batch_size_per_gpu_text_only, |
| ] |
| self.gradient_accumulate = gradient_accumulate |
| self.max_iter = max_iter |
| self.train_shuffle = train_shuffle |
| self.rank = get_mpi_rank() |
| self.world_size = get_mpi_size() |
| self.batch_size_per_gpu = [ |
| one_fwd_batch_size_per_gpu * gradient_accumulate, |
| one_fwd_batch_size_per_gpu_text_only * gradient_accumulate, |
| ] |
| self.prepare_t_versions = prepare_t_versions |
|
|
| self.vl_data_rate = vl_data_rate |
| self.vl_queue = vl_queue |
| self.l_queue = l_queue |
|
|
| self.skip_iter = skip |
| self.passed_iter = skip |
|
|
| def state_dict(self): |
| return {'passed_iter': self.passed_iter} |
|
|
| def load_state_dict(self, info): |
| self.skip_iter = info['passed_iter'] |
|
|
| def __iter__(self): |
| logging.info('we will skip {}'.format(self.skip_iter)) |
| vl_l_info = self.dataset.get_vl_l_info_from_cache() |
| vl_sampler = ScaleNodeSplitSampler( |
| self.dataset, |
| shuffle=self.train_shuffle, |
| prepare_t_versions=self.prepare_t_versions, |
| overwrite_dataset_len=vl_l_info['num_valid_vl_pair'], |
| queue=self.vl_queue, |
| ) |
| l_sampler = ScaleNodeSplitSampler( |
| self.dataset, |
| shuffle=self.train_shuffle, |
| start_offset=vl_l_info['num_valid_vl_pair'], |
| prepare_t_versions=[('caption', None)], |
| queue=self.l_queue, |
| ) |
| samplers = [vl_sampler, l_sampler] |
| samplers = [iter(s) for s in samplers] |
|
|
| if self.vl_data_rate is None: |
| self.vl_data_rate = vl_l_info['num_valid_vl_pair'] / vl_l_info['num_total'] |
| logging.info(f'{self.vl_data_rate}') |
|
|
| if self.skip_iter > 0: |
| vl_sampler.enable_prepare = False |
| l_sampler.enable_prepare = False |
|
|
| passed_data = [0, 0] |
| for iteration in range(self.max_iter): |
| random.seed(self.passed_iter) |
| r = random.random() |
| source_idx = 0 if r <= self.vl_data_rate else 1 |
| passed_data[source_idx] += 1 |
| if (iteration % 100) == 0: |
| logging.info(f'vl iter = {passed_data[0]}; l iter={passed_data[1]}') |
|
|
| batch_size_per_gpu = self.batch_size_per_gpu[source_idx] |
| one_fwd_batch_size_per_gpu = self.one_fwd_batch_size_per_gpu[source_idx] |
| |
| ret = [next(samplers[source_idx]) for _ in range(batch_size_per_gpu)] |
|
|
| if self.skip_iter > 0: |
| self.skip_iter -= 1 |
| else: |
| if not vl_sampler.enable_prepare: |
| vl_sampler.enable_prepare = True |
| if not l_sampler.enable_prepare: |
| l_sampler.enable_prepare = True |
| for i in range(self.gradient_accumulate): |
| yield [{ |
| 'idx': j, |
| 'iteration': self.passed_iter, |
| } for j in ret[ |
| i * one_fwd_batch_size_per_gpu: |
| (i + 1) * one_fwd_batch_size_per_gpu |
| ]] |
| self.passed_iter += 1 |
|
|
| def __len__(self): |
| return self.max_iter * self.gradient_accumulate |
|
|
| class ScaleNodeSplitVLPlusRandomLBatchSampler(Sampler): |
| def __init__(self, |
| dataset, |
| one_fwd_batch_size_per_gpu, |
| one_fwd_batch_size_per_gpu_text_only, |
| gradient_accumulate, |
| max_iter, |
| train_shuffle, |
| vl_data_rate, |
| prepare_t_versions=[], |
| vl_queue=None, |
| l_queue=None, |
| skip=0, |
| ): |
| print_frame_info() |
| self.dataset = dataset |
| self.one_fwd_batch_size_per_gpu = [ |
| one_fwd_batch_size_per_gpu, |
| one_fwd_batch_size_per_gpu_text_only, |
| ] |
| self.gradient_accumulate = gradient_accumulate |
| self.max_iter = max_iter |
| self.train_shuffle = train_shuffle |
| self.rank = get_mpi_rank() |
| self.world_size = get_mpi_size() |
| self.batch_size_per_gpu = [ |
| one_fwd_batch_size_per_gpu * gradient_accumulate, |
| one_fwd_batch_size_per_gpu_text_only * gradient_accumulate, |
| ] |
| self.prepare_t_versions = prepare_t_versions |
|
|
| self.vl_data_rate = vl_data_rate |
| self.vl_queue = vl_queue |
| self.l_queue = l_queue |
|
|
| self.skip_iter = skip |
| self.passed_iter = skip |
|
|
| def state_dict(self): |
| return {'passed_iter': self.passed_iter} |
|
|
| def load_state_dict(self, info): |
| self.skip_iter = info['passed_iter'] |
|
|
| def __iter__(self): |
| logging.info('we will skip {}'.format(self.skip_iter)) |
| vl_l_info = self.dataset.get_vl_l_info_from_cache() |
| vl_sampler = ScaleNodeSplitSampler( |
| self.dataset, |
| shuffle=self.train_shuffle, |
| prepare_t_versions=self.prepare_t_versions, |
| overwrite_dataset_len=vl_l_info['num_valid_vl_pair'], |
| queue=self.vl_queue, |
| ) |
| l_sampler = InfinityDistributedSampler( |
| self.dataset, |
| shuffle=self.train_shuffle, |
| start_offset=vl_l_info['num_valid_vl_pair'], |
| prepare_t_versions=[('caption', None)], |
| queue=self.l_queue, |
| ) |
| samplers = [vl_sampler, l_sampler] |
| samplers = [iter(s) for s in samplers] |
|
|
| if self.vl_data_rate is None: |
| self.vl_data_rate = vl_l_info['num_valid_vl_pair'] / vl_l_info['num_total'] |
| logging.info(f'{self.vl_data_rate}') |
|
|
| passed_data = [0, 0] |
| if self.skip_iter > 0: |
| vl_sampler.enable_prepare = False |
| for iteration in range(self.max_iter): |
| random.seed(self.passed_iter) |
| r = random.random() |
| source_idx = 0 if r <= self.vl_data_rate else 1 |
| passed_data[source_idx] += 1 |
| if (iteration % 100) == 0 and self.skip_iter <= 0: |
| logging.info(f'vl iter = {passed_data[0]}; l iter={passed_data[1]}') |
|
|
| batch_size_per_gpu = self.batch_size_per_gpu[source_idx] |
| one_fwd_batch_size_per_gpu = self.one_fwd_batch_size_per_gpu[source_idx] |
| |
| ret = [next(samplers[source_idx]) for _ in range(batch_size_per_gpu)] |
|
|
| if self.skip_iter > 0: |
| self.skip_iter -= 1 |
| else: |
| if not vl_sampler.enable_prepare: |
| vl_sampler.enable_prepare = True |
| for i in range(self.gradient_accumulate): |
| yield [{ |
| 'idx': j, |
| 'iteration': self.passed_iter, |
| } for j in ret[ |
| i * one_fwd_batch_size_per_gpu: |
| (i + 1) * one_fwd_batch_size_per_gpu |
| ]] |
| self.passed_iter += 1 |
|
|
| def __len__(self): |
| return self.max_iter * self.gradient_accumulate |
|
|
| class S3VLPlusS3LBatchSampler(Sampler): |
| def __init__(self, |
| dataset, |
| one_fwd_batch_size_per_gpu, |
| one_fwd_batch_size_per_gpu_text_only, |
| gradient_accumulate, |
| max_iter, |
| train_shuffle, |
| vl_data_rate, |
| prepare_t_versions=[], |
| disable_prepare=False, |
| vl_queue=None, |
| l_queue=None, |
| ): |
| print_frame_info() |
| self.dataset = dataset |
| self.one_fwd_batch_size_per_gpu = [ |
| one_fwd_batch_size_per_gpu, |
| one_fwd_batch_size_per_gpu_text_only, |
| ] |
| self.gradient_accumulate = gradient_accumulate |
| self.max_iter = max_iter |
| self.train_shuffle = train_shuffle |
| self.rank = get_mpi_rank() |
| self.world_size = get_mpi_size() |
| self.batch_size_per_gpu = [ |
| one_fwd_batch_size_per_gpu * gradient_accumulate, |
| one_fwd_batch_size_per_gpu_text_only * gradient_accumulate, |
| ] |
| self.prepare_t_versions = prepare_t_versions |
|
|
| self.vl_data_rate = vl_data_rate |
| self.disable_prepare = disable_prepare |
| self.vl_queue = vl_queue |
| self.l_queue = l_queue |
|
|
| self.skip_iter = 0 |
| self.passed_iter = 0 |
|
|
| def state_dict(self): |
| return {'passed_iter': self.passed_iter} |
|
|
| def load_state_dict(self, info): |
| self.skip_iter = info['passed_iter'] |
|
|
| def __iter__(self): |
| logging.info('we will skip {}'.format(self.skip_iter)) |
| vl_l_info = self.dataset.get_vl_l_info_from_cache() |
| vl_sampler = ScaleNodeSplitBySplitSampler( |
| self.dataset, |
| shuffle=self.train_shuffle, |
| prepare_t_versions=self.prepare_t_versions, |
| overwrite_dataset_len=vl_l_info['num_valid_vl_pair'], |
| disable_prepare=self.disable_prepare, |
| queue=self.vl_queue, |
| ) |
| l_sampler = ScaleNodeSplitBySplitSampler( |
| self.dataset, |
| shuffle=self.train_shuffle, |
| prepare_t_versions=[('caption', None)], |
| start_offset=vl_l_info['num_valid_vl_pair'], |
| prepare_queue_len=0, |
| disable_prepare=self.disable_prepare, |
| queue=self.l_queue, |
| ) |
| samplers = [vl_sampler, l_sampler] |
| samplers = [iter(s) for s in samplers] |
|
|
| if self.vl_data_rate is None: |
| self.vl_data_rate = vl_l_info['num_valid_vl_pair'] / vl_l_info['num_total'] |
| logging.info(f'{self.vl_data_rate}') |
|
|
| passed_data = [0, 0] |
| for iteration in range(self.max_iter): |
| random.seed(self.passed_iter) |
| r = random.random() |
| source_idx = 0 if r <= self.vl_data_rate else 1 |
| passed_data[source_idx] += 1 |
| if (iteration % 10) == 0: |
| logging.info(f'vl iter = {passed_data[0]}; l iter={passed_data[1]}') |
|
|
| batch_size_per_gpu = self.batch_size_per_gpu[source_idx] |
| one_fwd_batch_size_per_gpu = self.one_fwd_batch_size_per_gpu[source_idx] |
| |
| ret = [next(samplers[source_idx]) for _ in range(batch_size_per_gpu)] |
|
|
| if self.skip_iter > 0: |
| self.skip_iter -= 1 |
| else: |
| for i in range(self.gradient_accumulate): |
| yield [{ |
| 'idx': j, |
| 'iteration': self.passed_iter, |
| } for j in ret[ |
| i * one_fwd_batch_size_per_gpu: |
| (i + 1) * one_fwd_batch_size_per_gpu |
| ]] |
| self.passed_iter += 1 |
|
|
| def __len__(self): |
| return self.max_iter * self.gradient_accumulate |
|
|
|
|
|
|
