playground/Abbie-b200/dataloader/unsupervised.py

"""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)