playground/Abbie-orig/trainer_utils/dataloader.py

import json
import os
import random
import threading
from copy import deepcopy
from dataclasses import dataclass
from queue import Full, Queue
from typing import List, Optional, Tuple, Union

import torch
import torch.distributed as dist
from arpeggio import ArpeggioBaseDataloader, Chord, DataloaderArgs, TransformBase, create_dataloader, load_transform
from arpeggio.meta import DataSourceMeta
from arpeggio.version import __version__ as arpeggio_version
from omegaconf import DictConfig
from packaging.version import Version

from abbie.device_mesh_manager import DMM


assert Version(arpeggio_version) >= Version("0.2.0c1"), "Require atleast byted-thoth-arpeggio>=0.2.0c1"


@dataclass
class BufferedArpeggioDataloader:
    """Highly experimental buffer for arpeggio dataloader."""

    dataloader: ArpeggioBaseDataloader
    dtype: torch.dtype = torch.bfloat16

    def __post_init__(self):
        self.prev_state_dict = self.dataloader.state_dict()

        # [batch, state_dict, is_done, error]
        self.queue = Queue[Tuple[Chord, object, bool, Exception]](maxsize=1)
        self.finished = threading.Event()
        self.worker = threading.Thread(target=self.worker_fn, daemon=True)
        self.worker.start()

    def __del__(self):
        self.finished.set()

    def worker_fn(self):
        def put(obj):
            while not self.finished.is_set():
                try:
                    return self.queue.put(obj, timeout=0.5)
                except Full:
                    continue

        try:
            for batch in self.dataloader:
                state_dict = self.dataloader.state_dict()
                batch.to(self.dtype)
                put((batch, state_dict, False, None))
        except Exception as e:
            put((None, None, False, e))
        put((None, None, True, None))
        self.finished.set()

    def __iter__(self):
        while True:
            try:
                yield next(self)
            except StopIteration:
                self.finished.set()
                return

    def __next__(self):
        if self.finished.is_set():
            raise StopIteration

        batch, state_dict, done, exc = self.queue.get()
        if done:
            self.finished.set()
            raise StopIteration
        if exc is not None:
            self.finished.set()
            raise exc

        self.prev_state_dict = state_dict
        return batch

    def dump_checkpoint(self, checkpoint_dir: str):
        all_states = [{}] * self.dataloader.dp_size
        dist.all_gather_object(all_states, self.prev_state_dict, self.dataloader.dp_group)
        gathered_states = {k: v for s in all_states for k, v in s.items()}

        if self.dataloader.dp_rank == 0:
            os.makedirs(checkpoint_dir, exist_ok=True)
            with open(f"{checkpoint_dir}/dataloader_state.json", "w") as f:
                json.dump(gathered_states, f)

    def resume_from_checkpoint(self, checkpoint_dir: str):
        raise RuntimeError(
            "BufferedArpeggioDataloader does not support resume. Please wrap after resuming the base dataloader."
        )
        # with open(f"{checkpoint_dir}/dataloader_state.json", "w") as f:
        #     states = json.load(f)
        # self.dataloader.load_state_dict(states)
        # self.prev_state_dict = self.dataloader.state_dict()


@dataclass
class MultipleArpeggioDataloader:
    """Highly experimental class to support multiple arpeggio dataloaders."""

    dataloaders: List[ArpeggioBaseDataloader]
    seed: int

    def __post_init__(self):
        self.load_order = []
        for idx, dataloader in enumerate(self.dataloaders):
            self.load_order += [idx] * len(dataloader)

        rng = random.Random(self.seed)
        rng.shuffle(self.load_order)

    def __len__(self) -> int:
        return len(self.load_order)

    def __iter__(self):
        dataloader_iters = [iter(d) for d in self.dataloaders]
        for dataloader_idx in self.load_order:
            yield next(dataloader_iters[dataloader_idx])

    def convert_to_buffered(self, dtype: torch.dtype = torch.bfloat16):
        buffered_dataloaders = []
        for dataloader in self.dataloaders:
            buffered_dataloaders.append(BufferedArpeggioDataloader(dataloader, dtype=dtype))

        self._dataloaders = self.dataloaders
        self.dataloaders = buffered_dataloaders

    def dump_checkpoint(self, checkpoint_dir: str):
        for idx, dataloader in enumerate(self.dataloaders):
            dataloader.dump_checkpoint(f"{checkpoint_dir}/{idx}")

    def resume_from_checkpoint(self, checkpoint_dir: str):
        for idx, dataloader in enumerate(self.dataloaders):
            dataloader.resume_from_checkpoint(f"{checkpoint_dir}/{idx}")


def load_dataloader_and_training_steps(
    config: DictConfig,
    transform: Optional[TransformBase] = None,
) -> Tuple[ArpeggioBaseDataloader, int]:
    DMM.log_rank0("Creating dataloader")
    dataloader_args = DataloaderArgs(
        num_epoch=config.data.num_epoch,
        iterable=config.data.iterable,
        max_seq_len=config.data.max_seq_len,
        generate_infinitely=config.data.num_training_steps is not None,
        chunks_per_step=config.data.chunks_per_step,
        micro_batch_size=config.data.micro_batch_size,
        is_continuous_batch=config.data.is_continuous_batch,
        max_tokens_per_batch=config.data.max_tokens_per_batch,
        max_samples_per_batch=config.data.max_samples_per_batch,
        pad_to_multiple_of=config.data.pad_to_multiple_of,
        num_workers=config.data.num_workers,
        shuffle=config.data.shuffle,
        seed=config.data.seed,
        allow_skip_files=config.data.allow_skip_files,
    )

    if transform is None:
        tokenizer_path = config.model.tokenizer_path
        extra_kwargs = {}
        if config.data.transform_extra_kwargs is not None:
            extra_kwargs = config.data.transform_extra_kwargs

        transform = load_transform(model_path=tokenizer_path, **extra_kwargs)

    dataloader_dp_group = DMM.sp_dp_group
    if config.model.pp_distributed_dataloading:
        assert dataloader_args.chunks_per_step % DMM.pp_size == 0
        dataloader_args.chunks_per_step //= DMM.pp_size
        dataloader_dp_group = DMM.pp_x_sp_dp_group

    if config.data.multi_source_configs is None:
        # Base case, single dataloader
        dataloader = create_dataloader(
            data_source_metas=config.data.data_source_metas,
            patterns=config.data.patterns,
            args=dataloader_args,
            transform=transform,
            dp_group=dataloader_dp_group,
            dataset_meta_paths=config.data.get("dataset_meta_paths", None),
        )
        DMM.log_rank0(f"Created dataloader with args: {dataloader.args}")

    else:
        # Handle multiple dataloaders
        with open(config.data.multi_source_configs, "r") as f:
            multi_source_configs = json.load(f)
        assert isinstance(multi_source_configs, list), (
            f"Improper format of multi_source_configs, received {multi_source_configs}"
        )

        # Currently does not support generate infinitely
        dataloader_args.generate_infinitely = False

        dataloaders = []
        for source_metas in multi_source_configs:
            source_metas = parse_source_metas(source_metas)
            dataloader_name = source_metas[0]["name"]  # Just sample first one
            DMM.log_rank0(f"Building dataloader for {dataloader_name}")
            dataloader = create_dataloader(
                # Merging would reduce memory pressure
                data_source_metas=merge_source_metas(source_metas),
                args=dataloader_args,
                transform=transform,
                dp_group=dataloader_dp_group,
            )
            DMM.log_rank0(f"Created dataloader with args: {dataloader.args}")
            DMM.log_rank0(f"dataloader max steps: {len(dataloader)}")

            dataloaders.append(dataloader)

        dataloader = MultipleArpeggioDataloader(dataloaders, seed=config.data.seed)

    # Determine number of steps to train
    num_training_steps = config.data.num_training_steps
    if config.data.num_training_steps is None:
        num_training_steps = len(dataloader)

    return dataloader, num_training_steps


def parse_source_metas(metas) -> List[DataSourceMeta]:
    assert isinstance(metas, list), f"Improper format of data source metas, received {metas}"

    for idx, meta in enumerate(metas):
        sample_rate = 1.0
        if isinstance(meta, (list, tuple)):
            # Special format to support per-dataset sampling
            meta, sample_rate = meta

        if isinstance(meta, str):
            with open(meta, "r") as f:
                meta = json.load(f)

        assert isinstance(meta, dict)

        if sample_rate != 1.0:
            meta["filepaths"] = sample_files(meta["filepaths"], sample_rate)

        metas[idx] = meta

    return metas


def merge_source_metas(metas: List[DataSourceMeta]) -> DataSourceMeta:
    assert len(metas) >= 1

    filepaths = []
    total_num_samples = 0
    total_num_tokens = 0

    for meta in metas:
        filepaths.extend(meta["filepaths"])
        total_num_samples += meta["avg_samples_per_file"] * len(meta["filepaths"])
        total_num_tokens += meta["avg_tokens_per_file"] * len(meta["filepaths"])

    merged_meta = deepcopy(metas[0])
    merged_meta["filepaths"] = filepaths
    merged_meta["avg_seq_len"] = total_num_tokens / total_num_samples
    merged_meta["avg_samples_per_file"] = total_num_samples / len(filepaths)
    merged_meta["avg_tokens_per_file"] = total_num_tokens / len(filepaths)

    return merged_meta


def sample_files(filepaths: List[str], sample_rate: Union[str, float]) -> List[str]:
    if isinstance(sample_rate, str):
        sample_rate = int(sample_rate.split("%")[0]) / 100

    if sample_rate < 1:
        n_sample = int(len(filepaths) * sample_rate)
        return filepaths[:n_sample]

    elif sample_rate > 1:
        return filepaths * int(sample_rate // 1) + sample_files(filepaths, sample_rate % 1)

    return filepaths