"""Unsupervised datamodule for GPT pretraining""" import logging import os import sys import warnings import tempfile import random import copy import torch import torch.nn.functional as F from einops import rearrange from typing import Union, List from torch.utils.data._utils.collate import default_collate from dataloader.cruise_loader import DistributedCruiseDataLoader from dataloader.hdfs_io import hlist_files, hcopy from dataloader.cloud.google_accessor import get_google_target_blob_file_list, is_google_path from dataloader.cloud.azure_accessor import get_azure_target_blob_file_list, is_azure_path from transformers import AutoTokenizer from dataloader.utils import is_bitwise_ckpt_enable from dataloader.config import TrainerConfig from dualpipe.module.parallel_states import get_dist_env try: from metadata.dataset import get_files_and_meta except ImportError: pass def add_length_meta(path, dict_files, azure_access_enabled=False, google_access_enabled=False): files = [] if isinstance(path, list): assert len(path) == 1, "The current path setting only supports a single input path." path = path[0] files, file_lengths = get_files_and_meta(path) if len(files) == 0: files = hlist_files(path) else: dict_files.update(file_lengths) if is_azure_path(path): assert azure_access_enabled, 'Providing azure path requires to turn --data.use_azure_dataset to be True' warnings.warn(f"Using azure as training and validate storage for path: {path}") files = get_azure_target_blob_file_list(path) elif is_google_path(path): assert google_access_enabled, 'Providing google cloud storage path requires to turn --use_google_dataset to be True' warnings.warn(f"Using google as training and validate storage for path: {path}") files = get_google_target_blob_file_list(path) elif not files: raise Exception("Currently don't support directly using hdfs ls to get files, please provide a list of files.") return files class RawTextProcessor: r""" Args: tokenizer: the name of the pretrained tokenizer, e.g., "bigscience/bloom" text_keys: keys that contains text as values in the input. max_seq_len: max length that the model accept, if data is not enough, pad_token_id will be used. drop_last: if text length is not divisible by max_seq_len, set this field to False will pad the remainder. stride: if 'slidng_window' is not -1, the text will be sampled with sliding window of stride 'stride'. """ def __init__(self, tokenizer: str, text_keys: Union[str, List[str]], max_seq_len: int, trainer_config: TrainerConfig, drop_last: bool = False, stride=-1, dyn_bsz=False, **kwargs): """ src_weights: the yaml path containing the sources and their weights. """ self.trainer_config = trainer_config if not isinstance(text_keys, list): text_keys = [text_keys] self.text_keys = text_keys if not isinstance(tokenizer, str): # from created tokenizer object self.tokenizer = tokenizer else: self.tokenizer = AutoTokenizer.from_pretrained(tokenizer) self.max_seq_len = max_seq_len self.drop_last = drop_last self.stride = stride # We will automatically convert token list to tensor self.kwargs = kwargs self.dyn_bsz = dyn_bsz self.fim_prob = 0 self.max_n_segm = 3 self.seq_lens = [max_seq_len] def get_next_subseq(self, concatenated_examples, start, end, max_seq_len, overlap_len, stride): """ concatenated_examples: dict, including attention_mask and input_ids For concatenated_examples, valid interval: [start, end) reverse: The order to split sequences """ def get_slice(examples, left, right, slice_len, overlap_len=-1): if overlap_len != -1 and left >= len(examples['input_ids'])-overlap_len: left = max(0, len(examples['input_ids'])-overlap_len) # 切分后出现的不足overlap_len的seq补齐overlap_len seq = {key: value[left:left+slice_len] for key, value in examples.items()} else: seq = {key: value[left:left+slice_len] for key, value in examples.items()} return seq # Fill in the middle seq = get_slice(concatenated_examples, left=start, right=end, slice_len=max_seq_len, overlap_len=overlap_len) start = start + stride return seq, start, end def tokenizewaug(self, text_dict, data_dict): """ Tokenization will happen in each field. Output: concat_text attention_mask loss_mask """ def tokenize(raw_text): results = self.tokenizer(raw_text, **self.kwargs) results['loss_mask'] = [1]*len(results['input_ids']) return results def append_eos(text_dict, loss_mask=False, mask_val=1): text_dict['input_ids'][0].append(self.tokenizer.eos_token_id) text_dict['attention_mask'][0].append(1) if loss_mask is True: text_dict['loss_mask'][0].append(mask_val) return text_dict def append_content(text_dict, raw_text, loss_mask=False, mask_val=1): cur_text = tokenize(raw_text) text_dict['input_ids'][0].extend(cur_text['input_ids']) text_dict['attention_mask'][0].extend(cur_text['attention_mask']) if loss_mask is True: text_dict['loss_mask'][0].extend([x*mask_val for x in cur_text['loss_mask']]) return text_dict text_dict = append_content(text_dict, data_dict['content_split'], loss_mask=False) mask_val_for_eos = 1 if "pos" in data_dict['meta'] and "max_pos" in data_dict['meta']: if data_dict['meta']["pos"] == data_dict['meta']["max_pos"]: text_dict = append_eos(text_dict, mask_val=mask_val_for_eos) else: text_dict = append_eos(text_dict, mask_val=mask_val_for_eos) return text_dict def transform(self, data_dict): data_dict = copy.deepcopy(dict(data_dict)) return self.base_transform(data_dict) def base_transform(self, data_dict): text_dict = {'sources': [], 'chunk_id': [], 'weights': [], 'input_ids': [[]], 'attention_mask': [[]], 'categories': [], 'datasets': []} for key in self.text_keys: if 'content_split' in key: if len(data_dict[key]) <= 0: print(f"Empty string exists: {data_dict}", file=sys.stderr) text_dict = self.tokenizewaug(text_dict, data_dict) elif 'meta' in key: src = data_dict['meta']['source'] weight = inst_weight = data_dict['meta'].get('weight', 1.0) if 'extra' in data_dict['meta']: del data_dict['meta']['extra'] text_dict['sources'].append([src]) text_dict['categories'].append([data_dict['meta'].get('category', 'unknown')]) text_dict['datasets'].append([data_dict['meta'].get('dataset', 'unknown')]) text_dict['chunk_id'].append([data_dict['meta'].get('chunk_id', 'unknown')]) text_dict['weights'].append([weight]) if len(text_dict['sources']) == 0: text_dict['sources'].append(["unknown"]) text_dict['categories'].append(["unknown"]) text_dict["datasets"].append(["unknown"]) text_dict["chunk_id"].append(["unknown"]) text_dict["weights"].append([1.0]) return self.group_texts(text_dict, data_dict['content_split']) def rmpad_trans( self, batch_data, hidden_size, pad_idx, max_pos_seq_len, pe_type ): def create_mask(labels, pad_idx): labels = labels loss_mask = torch.ones(labels.shape, device=labels.device) loss_mask[labels == pad_idx] = 0 return loss_mask.cpu() def generated_cos_sin(max_pos_seq_len, device): projection_size = 2048 hidden_size_per_attention_head = projection_size // 16 base = 10000 inv_freq = 1.0 / (base ** \ (torch.arange(0, hidden_size_per_attention_head, 2).float() / hidden_size_per_attention_head)) t = torch.arange(max_pos_seq_len, device=device).type_as(inv_freq) # self.scale = 1 / 16 # 1/8 1/16 # t *= self.scale freqs = torch.einsum("i,j->ij", t, inv_freq) # T, D/2 freqs = torch.cat([freqs, freqs], dim=1) # T,D/2 -> T,D self.cos = freqs.cos().bfloat16() # T,D self.sin = freqs.sin().bfloat16() # T,D def generate_pos_embs(seq_lens, max_pos_seq_len, device=torch.device('cuda'), s_max=None): if not hasattr(self, 'cos') or not hasattr(self, 'sin'): generated_cos_sin(max_pos_seq_len, device) cos_embs = [] sin_embs = [] bsz = len(seq_lens) - 1 for i in range(bsz): r = seq_lens[i+1] - seq_lens[i] # if i == bsz - 1 and s_max is not None: # r = max(s_max, seq_lens[i+1]) - seq_lens[i] cos_embs.append(self.cos[:r]) sin_embs.append(self.sin[:r]) if s_max > seq_lens[-1]: n_pad = s_max - seq_lens[-1] cos_embs.append(self.cos[:n_pad]) sin_embs.append(self.sin[:n_pad]) cos_embs = torch.cat(cos_embs, dim=0) #.to(device) # N,D sin_embs = torch.cat(sin_embs, dim=0) #.to(device) # N,D return cos_embs, sin_embs input_shapes = [] input_shapes_unpad = [] for b in batch_data: b['labels'] = b['input_ids'] input_ids = b['input_ids'] input_shape = input_ids.size() labels = b['labels'] input_ids = input_ids.view(-1, input_shape[-1]) attention_mask = b['attention_mask'] seqlens_in_batch = attention_mask.sum(dim=-1, dtype=torch.int32) max_seqlen_in_batch = seqlens_in_batch.max().item() total_seqlen_in_batch = seqlens_in_batch.sum().item() cu_seqlens = F.pad(torch.cumsum(seqlens_in_batch, dim=0, dtype=torch.torch.int32), (1, 0)) indices = torch.nonzero(attention_mask.flatten(), as_tuple=False).flatten() input_ids = rearrange(input_ids, 'b s ... -> (b s) ...') input_ids = input_ids[indices] b['max_seqlen_in_batch'] = max_seqlen_in_batch b['total_seqlen_in_batch'] = total_seqlen_in_batch b['seq_lens'] = cu_seqlens b['host_seqlens'] = cu_seqlens.cpu() b['lbl_seq_lens'] = (cu_seqlens[1:]-1).long() b['word_idx'] = indices b['pos_idx'] = (indices % input_shape[-1]) seq_len = input_ids.shape[0] pad_seq_len = seq_len acc_pad = 0 seq_len_unpad = seq_len - acc_pad input_shapes.append(torch.Size([seq_len, 1, hidden_size])) input_shapes_unpad.append(torch.Size([seq_len_unpad, 1, hidden_size])) labels = labels.view(-1)[indices] shift_labels = torch.cat((labels[1:], labels.new_ones((1))*pad_idx)) shift_labels.requires_grad = False shift_labels[b['lbl_seq_lens']] = pad_idx shift_labels = shift_labels.unsqueeze(0) if 'loss_mask' not in b: loss_mask = create_mask(shift_labels, pad_idx) b['rmpad_loss_mask'] = loss_mask # (1, bs) else: loss_masks = rearrange(b['loss_mask'], 'b s -> (b s)') b['rmpad_loss_mask'] = loss_masks[indices].unsqueeze(0) # (1, bs) del b['loss_mask'] cos_embs_indices, sin_embs_indices = None, None if pe_type == 'rope': cos_embs_indices, sin_embs_indices = generate_pos_embs( b['host_seqlens'], max_pos_seq_len, b['host_seqlens'].device, s_max=pad_seq_len, ) b['cos_embs_indices'] = cos_embs_indices b['sin_embs_indices'] = sin_embs_indices assert len(batch_data) >= 1 batch_data[0]['input_shapes'] = input_shapes batch_data[0]['input_shapes_unpad'] = input_shapes_unpad def to_cuda(self, batch): cpu_tensor = {} # {'host_seqlens', 'rmpad_loss_mask', 'weights'} for b in batch: for k, v in b.items(): if k in cpu_tensor: continue elif isinstance(v, torch.Tensor): b[k] = v.cuda(non_blocking=True) elif isinstance(v, dict): self.to_cuda(v) def batch_transform(self, batch_data): results = [default_collate(x) for x in batch_data] global_config = self.trainer_config hidden_size = int(global_config.hidden_size) pad_idx = global_config.pad_idx max_pos_seq_len = global_config.max_position_embeddings pe_type = global_config.position_embeddings_type self.rmpad_trans( results, hidden_size, pad_idx, max_pos_seq_len, pe_type, ) return results def group_texts(self, examples, raw_text): cur_max_seq_len = random.choices(self.seq_lens, [1.0])[0] cur_overlaplen = self.max_seq_len - self.stride if self.stride != -1 else -1 cur_stride = cur_max_seq_len - cur_overlaplen if self.stride != -1 else cur_max_seq_len # 不同seq lens下优先保证overlap_len一致 assert cur_stride > 0 concatenated_examples = {k: sum(examples[k], []) for k in examples.keys()} subseqs = [] start, end = 0, len(concatenated_examples['input_ids']) while True: subseq, start, end = self.get_next_subseq(concatenated_examples, start=start, end=end, max_seq_len=cur_max_seq_len, overlap_len=cur_overlaplen, stride=cur_stride) subseqs.append(subseq) if start >= end: break n_subseqs = len(subseqs) assert n_subseqs > 0 for key in concatenated_examples: if 'source' in key or 'chunk_id' in key or 'weight' in key or 'categor' in key or 'dataset' in key: continue # Split subseqs if 'mask' in key: pad_token_id = 0 elif self.tokenizer.pad_token_id is None: pad_token_id = self.tokenizer.eos_token_id else: pad_token_id = self.tokenizer.pad_token_id concatenated_examples[key] = [] for i in range(n_subseqs): if len(subseqs[i][key]) < self.max_seq_len: subseqs[i][key].extend([pad_token_id] * (self.max_seq_len-len(subseqs[i][key]))) concatenated_examples[key].extend(subseqs[i][key]) total_length = len(concatenated_examples['input_ids']) tot_byte_length = len(raw_text.encode('utf-8')) # Split by chunks of max_len. outputs = [] assert total_length > 0 for i in range(0, total_length, self.max_seq_len): result = { k: t if 'source' in k or 'chunk_id' in k or 'weight' in k or 'categor' in k or 'dataset' in k else torch.as_tensor(t[i: i + self.max_seq_len]) for k, t in concatenated_examples.items() } ids = concatenated_examples['input_ids'][i: i + self.max_seq_len] ids = [x for x in ids if x != self.tokenizer.pad_token_id] result['input_texts'] = [self.tokenizer.decode(ids)] result['byte_lengths'] = [len(result['input_texts'][0].encode('utf-8'))] result['tot_byte_lengths'] = [tot_byte_length] if result['byte_lengths'][0] == 0: result['byte_lengths'][0] = 1 outputs.append(result) return outputs class SaharaDatamodule: """Sahara pretrain dataset module.""" def __init__(self, rank, trainer_config: TrainerConfig ): self.global_rank = rank self.hparams = trainer_config if trainer_config.return_source and 'meta' not in trainer_config.text_keys: trainer_config.text_keys.append('meta') #global_config = last_cli().hparams if trainer_config.bsz_warmup: warmup_rate = trainer_config.warmup_step_rate max_epochs = trainer_config.max_epochs trainer_config.warmup_step_rate = warmup_rate * max_epochs self.tokenizer = None if trainer_config.val_batch_size == -1: trainer_config.val_batch_size = trainer_config.train_batch_size # set up val step self.val_steps = -1 # no repeat for megatron def local_rank_zero_prepare(self) -> None: if self.hparams.tokenizer.startswith('hdfs'): print("Downloading HF tokenizer ....") # try download it to local once per node and load it in setup os.makedirs('/opt/tiger/Abbie/tmp', exist_ok=True) tmp_dir = os.path.join("/opt/tiger/Abbie/tmp", os.path.basename(self.hparams.tokenizer)) hcopy(self.hparams.tokenizer, tmp_dir) print(f"Downloaded HF tokenizer .... in {tmp_dir}") else: logging.info(f"Prefetching HF tokenizers {self.hparams.tokenizer} on local rank zero...") AutoTokenizer.from_pretrained(self.hparams.tokenizer) def setup(self): if self.hparams.tokenizer.startswith('hdfs'): # try download it to local once per node and load it in setup tmp_dir = os.path.join("/opt/tiger/Abbie/tmp", os.path.basename(self.hparams.tokenizer)) assert self.hparams.tokenizer_type == "bbpe", 'Only supporting BBPE at this moment.' self.tokenizer = AutoTokenizer.from_pretrained(tmp_dir, local_files_only=True) else: self.tokenizer = AutoTokenizer.from_pretrained(self.hparams.tokenizer, max_len=-1) def rank_zero_info(self, text): if self.global_rank == 0: print(text) def train_dataloader(self, train_steps, warmup_steps): if self.hparams.train_size > 0: self.train_steps = train_steps else: self.train_steps = -1 self.rank_zero_info(f'Estimated training steps: {self.train_steps}') length_meta = {} train_files = add_length_meta(self.hparams.train_path, length_meta, azure_access_enabled=self.hparams.use_azure_dataset, google_access_enabled=self.hparams.use_google_dataset) train_files = [x for x in train_files if x.endswith('.parquet')] train_files = sorted(train_files) self.rank_zero_info(f"Fetched {len(train_files)} training files.") if self.hparams.tokenizer_type == "bbpe": tokenizer_kwargs = {"return_token_type_ids": False} else: tokenizer_kwargs = {} loader = DistributedCruiseDataLoader( data_sources=train_files, batch_sizes=self.hparams.train_batch_size, num_workers=self.hparams.train_num_workers, predefined_steps=self.train_steps, shuffle=True, drop_last=True, pin_memory=True, resumt_ckpt_path=self.hparams.resume_ckpt_path, parquet_cache_on=True, processor=RawTextProcessor( tokenizer=self.tokenizer if self.tokenizer is not None else self.hparams.tokenizer, text_keys=self.hparams.text_keys, max_seq_len=self.hparams.max_seq_len, drop_last=False, stride=self.hparams.stride, dyn_bsz=self.hparams.dyn_bsz, trainer_config=self.hparams, **tokenizer_kwargs), dyn_bsz=self.hparams.dyn_bsz, num_warmup_steps=warmup_steps, pad_idx=self.hparams.pad_idx, micro_batch_size=self.hparams.micro_batch_size, enable_bitwise_resume=is_bitwise_ckpt_enable(), length_meta=length_meta, use_azure_dataset=self.hparams.use_azure_dataset, use_google_dataset=self.hparams.use_google_dataset ) self._train_dataloader = loader return loader def val_dataloader(self): if not self.hparams.val_path: return iter([]) val_path_list = self.hparams.val_path if not isinstance(val_path_list, (list, tuple)): val_path_list = [val_path_list] if not isinstance(self.hparams.val_size, (list, tuple)): assert self.hparams.val_size == -1, "Size mismatch for data.val_path and data.val_size if not using default length" val_size_list = [self.hparams.val_size for i in range(len(val_path_list))] else: val_size_list = self.hparams.val_size estimated_val_steps = [max(int(val_size / self.hparams.val_batch_size /self.hparams.max_seq_len / get_dist_env().dp_size), 1) if val_size != -1 else -1 for val_size in val_size_list] loaders = [] length_meta = {} for val_step, val_path in zip(estimated_val_steps, val_path_list): self.print(f"val_step:{val_step}. val_path:{val_path}") val_files = [] for each in val_path.split(','): val_files.extend([x for x in add_length_meta(each, length_meta, azure_access_enabled=self.hparams.use_azure_dataset, google_access_enabled=self.hparams.use_google_dataset) if x.endswith('.parquet')]) self.rank_zero_info(f"Fetched {len(val_files)} val files under {val_path}.") use_dyn_bsz = True loader = DistributedCruiseDataLoader( data_sources=[val_files], batch_sizes=[self.hparams.val_batch_size], num_workers=self.hparams.val_num_workers, predefined_steps=self.val_steps, shuffle=False, drop_last=False, pin_memory=True, resumt_ckpt_path=None, parquet_cache_on=True, processor=RawTextProcessor( tokenizer=self.tokenizer if self.tokenizer is not None else self.hparams.tokenizer, text_keys=self.hparams.text_keys, max_seq_len=self.hparams.max_seq_len, drop_last=False, dyn_bsz=use_dyn_bsz, trainer_config=self.hparams, ), dyn_bsz=use_dyn_bsz, pad_idx=self.hparams.pad_idx, micro_batch_size=self.hparams.micro_batch_size, validation=True, length_meta=length_meta ) loaders.append(loader) self._val_dataloader = loaders return loaders def transfer_batch_to_device(self, batch, device): cpu_tensor = {'host_seqlens', 'weights', 'byte_lengths'} for b in batch: for k, v in b.items(): if k in cpu_tensor: continue b[k] = super().transfer_batch_to_device(b[k], device) return batch def state_dict(self): if hasattr(self, "train_dataloader"): if hasattr(self._train_dataloader, "__getstate__"): return self._train_dataloader.__getstate__() return {} def load_state_dict(self, state_dict): if not state_dict: return if hasattr(self, "train_dataloader"): if hasattr(self._train_dataloader, "__setstate__"): self._train_dataloader.__setstate__(state_dict)