Upload aux_files/train_mock_data_order.py with huggingface_hub

aux_files/train_mock_data_order.py

@@ -1 +1,436 @@
-Gemstones Training Dataset - Worker sharded version
+"""
+This file mocks the startup of the lit-gpt-dev train.py file to materialize the data order.
+
+It either iterates the data for inspection, or converts the files to the parquet format,
+optionally consolidating each worker's data into a single file for better portability.
+"""
+
+import os
+import shutil
+from functools import partial
+from multiprocessing import Pool
+import random
+from tqdm import tqdm
+
+from jsonargparse import CLI
+from pathlib import Path
+
+from torch.utils.data import DataLoader
+
+from datasets import Dataset, load_dataset
+
+from litgpt.settings import CLISettings, DataEntry
+from litgpt.tokenizer import Tokenizer
+from litgpt.packed_cycle_dataset import CombinedDataset, PackedDataset
+from litgpt.data_scheduler_utils import DataSchedulerTracker, DataScheduler
+from litgpt.data_loading_utils import generic_collate_fn
+
+os.environ["OUTPUT_DIR"] = f"{os.path.dirname(__file__)}/output/data_order_test"
+os.makedirs(os.environ["OUTPUT_DIR"], exist_ok=True)
+
+# The settings class will look for these to set the topology and localization handles.
+# for some we set them as defaults, but the world will be configured to be larger and multiprocessing
+# will be used to parallelize the data order materialization.
+
+# defaults
+os.environ["SLURM_JOB_ID"] = "0"
+os.environ["SLURM_ARRAY_JOB_ID"] = "0"
+os.environ["SLURM_ARRAY_TASK_ID"] = "0"
+os.environ["SLURM_ARRAY_TASK_COUNT"] = "1"
+os.environ["MASTER_ADDR"] = "computer0"
+os.environ["MASTER_PORT"] = "12345"
+
+# world size controls the number of shards of work that we will mock
+# os.environ["SLURM_JOB_NUM_NODES"] = "1"  # 1 nodes
+# os.environ["WORLD_SIZE"] = f"{1 * 1}"  # 1 nodes, 1 GPUs each
+# os.environ["SLURM_JOB_NUM_NODES"] = "4"  # 4 nodes
+# os.environ["WORLD_SIZE"] = f"{4 * 8}"  # 4 nodes, 8 GPUs each
+os.environ["SLURM_JOB_NUM_NODES"] = "32"  # 32 nodes
+os.environ["WORLD_SIZE"] = f"{32 * 8}"  # 32 nodes, 8 GPUs each
+
+os.environ["RANK"] = "0"
+os.environ["SLURM_PROCID"] = "0"
+# in case we want to mock a smaller number of tasks per node
+os.environ["SLURM_NTASKS_PER_NODE"] = str(min(8, int(os.environ["WORLD_SIZE"])))
+
+# we can run with a smaller real worker pool size
+# but still do the same number of shards of work, just in batches of size pool
+# NUM_PROC = int(os.environ["WORLD_SIZE"])
+# NUM_PROC = 1
+# NUM_PROC = 32
+NUM_PROC = 64
+
+assert NUM_PROC <= int(os.environ["WORLD_SIZE"]), (
+    f"NUM_PROC ({NUM_PROC}) must be less than or equal to WORLD_SIZE ({os.environ['WORLD_SIZE']}). "
+    "This is to ensure that we do not exceed the number of available ranks in the mock distributed setup."
+)
+
+# when mocking the parallel workers, this is not used
+# when linearizing, this determines how many chunks to save the complete dataset into
+PARQUET_SHARDS = None
+# PARQUET_SHARDS = 32
+# PARQUET_SHARDS = 256
+
+assert PARQUET_SHARDS is None or (
+    int(os.environ["WORLD_SIZE"]) == 1
+), f"PARQUET_SHARDS ({PARQUET_SHARDS}) must be None when WORLD_SIZE ({os.environ['WORLD_SIZE']}) is greater than 1. "
+
+
+# we also mock a fabric-like class to hold the key fields like world_size and global_rank
+# that we will use to configure the local view of the dataset for each "rank"
+# when spinning up the multiprocessing workers.
+class MockFabric:
+    """Mock fabric to simulate distributed settings."""
+
+    def __init__(self, global_rank: int, world_size: int):
+        """Initialize the mock fabric with global rank and world size."""
+        self.global_rank = global_rank
+        self.world_size = world_size
+
+    def print(self, *args, **kwargs):
+        """Mock fabric.print function to simulate distributed printing."""
+        print(*args, **kwargs)
+
+
+def create_dataloader(
+    data_config: list[DataEntry],
+    batch_size: int,
+    block_size: int,
+    n_chunks: int,
+    data_dir: str,
+    fabric: MockFabric,
+    seed: int = 1337,
+    *,
+    cfg: CLISettings,
+    tokenizer: Tokenizer,
+    get_filenames_only: bool = False,
+    filenames: list = None,
+):
+    global_data_dir = data_dir
+    datasets = []
+    for curr_config in data_config:
+
+        # NOTE omitted other blocks here
+
+        prefix = curr_config.prefix
+
+        if curr_config.data_dir is not None:
+            data_dir = curr_config.data_dir
+        else:
+            data_dir = global_data_dir
+
+        if get_filenames_only:
+            if fabric.global_rank == 0:
+                filenames = [str(pth) for pth in sorted(Path(data_dir).glob(f"{prefix}*"))]
+                if cfg.shuffle_filenames:
+                    random.seed(seed)
+                    random.shuffle(filenames)  # inplace
+                if not filenames:
+                    raise FileNotFoundError(f"No files found at {str(data_dir)} with prefix {prefix}.")
+            else:
+                filenames: list[str] = None  # type: ignore # hashtag believe
+
+            # If we only want to get the filenames, return them directly.
+            return filenames, None
+        else:
+            pass
+
+        # filenames = fabric.broadcast(filenames, 0)  # this is a blocking op from rank 0 to all other ranks
+        # we can't broadcast in the mock multiprocessing context, so the filenames are
+        # constructed once and passed to all workers
+        assert filenames is not None, ""
+
+        # log after broadcast so we know we passed it.
+        if fabric.global_rank == 0:
+            num_processes = (fabric.world_size,)
+            process_rank = (fabric.global_rank,)
+            fabric.print(
+                f"Rank ({process_rank}/{num_processes}) glob'd {len(filenames)} files"
+                f" from {data_dir}{f' w/ prefix {prefix}' if prefix not in ['','*'] else ''},"
+                f" files[:3]: {filenames[:3]}"
+            )
+
+        dataset = PackedDataset(
+            filenames,
+            n_chunks=n_chunks,
+            block_size=block_size,
+            shuffle=cfg.shuffle_blocks,
+            seed=seed,
+            num_processes=fabric.world_size,
+            process_rank=fabric.global_rank,
+            data_id=prefix,
+            return_data_id=curr_config.return_data_id or cfg.return_data_id,
+        )
+
+        # NOTE omitted other blocks here
+
+        datasets.append(dataset)
+
+    if not datasets:
+        raise RuntimeError(
+            f"No data found at {data_dir}. Make sure you ran prepare_redpajama.py to create the dataset."
+        )
+
+    weights = [curr_config.weight for curr_config in data_config]
+    data_scheduler_tracker = DataSchedulerTracker(weights)
+
+    combined_dataset = CombinedDataset(
+        datasets=datasets, seed=seed, data_scheduler_tracker=data_scheduler_tracker, data_telemetry=cfg.data_telemetry
+    )
+
+    parametrized_collate_fn = partial(
+        generic_collate_fn,
+        tokenizer=tokenizer,
+        block_size=cfg.loader_block_size,
+        pad_to_block_size=cfg.pad_to_block_size,
+        add_bos=cfg.add_bos,
+        add_eos=cfg.add_eos,
+        collate_checks_enabled=cfg.collate_checks_enabled,
+        all_block_size_tensors=cfg.all_block_size_tensors,
+        no_shift_ret_raw_tokens=True,  # we don't shift the tokens in this mock
+    )
+
+    return (
+        DataLoader(
+            combined_dataset,
+            batch_size=batch_size,
+            shuffle=False,
+            pin_memory=False,
+            collate_fn=parametrized_collate_fn,
+            num_workers=cfg.dataloader_num_workers,
+        ),
+        data_scheduler_tracker,
+    )
+
+
+def create_dataloaders(
+    batch_size: int,
+    block_size: int,
+    fabric: MockFabric,
+    seed: int = 1337,
+    *,
+    cfg: CLISettings,
+    tokenizer: Tokenizer,
+    get_filenames_only: bool = False,
+    train_filenames: list = None,
+    val_filenames: list = None,
+):
+    cfg.train_dataset_prefixes = [ds.prefix for ds in cfg.data_config["train_data"]]
+    cfg.val_dataset_prefixes = (
+        [ds.prefix for ds in cfg.data_config["val_data"]] if "val_data" in cfg.data_config else []
+    )
+
+    fabric.print(f"Creating dataloaders with seed: {seed}")
+    train_dataloader, data_scheduler_tracker = create_dataloader(
+        cfg.data_config["train_data"],
+        batch_size=batch_size,
+        block_size=block_size,
+        n_chunks=cfg.n_chunks,
+        fabric=fabric,
+        data_dir=cfg.train_data_dir,
+        seed=seed,
+        cfg=cfg,
+        tokenizer=tokenizer,
+        get_filenames_only=get_filenames_only,
+        filenames=train_filenames,
+    )
+    val_dataloader, val_data_scheduler_tracker = (
+        create_dataloader(
+            cfg.data_config["val_data"],
+            batch_size=batch_size,
+            block_size=block_size,
+            n_chunks=cfg.n_chunks,
+            fabric=fabric,
+            data_dir=cfg.val_data_dir,
+            seed=seed,
+            cfg=cfg,
+            tokenizer=tokenizer,
+            get_filenames_only=get_filenames_only,
+            filenames=val_filenames,
+        )
+        if "val_data" in cfg.data_config
+        else (None, None)
+    )
+    return train_dataloader, val_dataloader, data_scheduler_tracker, val_data_scheduler_tracker
+
+
+def materialize_worker_dataset(
+    worker_id: int,
+    total_workers: int,
+    cfg: CLISettings,
+    tokenizer: Tokenizer,
+    get_filenames_only: bool = False,
+    train_filenames: list = None,
+    val_filenames: list = None,
+    ret_dataloaders: bool = True,
+    iterate_k_steps: int = None,
+    save_k_steps_to_parquet: int = None,
+):
+    """Builds a mock dataset for a worker based on its ID and total workers."""
+    # Simulate some data order materialization logic
+    fabric = MockFabric(global_rank=worker_id, world_size=total_workers)
+
+    # For demonstration, we just print the worker info
+    print(f"Worker ready ({fabric.global_rank}/{fabric.world_size})")
+
+    train_dataloader, val_dataloader, data_scheduler_tracker, val_data_scheduler_tracker = create_dataloaders(
+        batch_size=cfg.micro_batch_size,
+        block_size=cfg.loader_block_size,
+        fabric=fabric,
+        seed=(cfg.seed + fabric.global_rank),
+        cfg=cfg,
+        tokenizer=tokenizer,
+        get_filenames_only=get_filenames_only,
+        train_filenames=train_filenames,
+        val_filenames=val_filenames,
+    )
+    if get_filenames_only:
+        # will have resulted in train_filenames, val_filenames, None, None
+        return train_dataloader, val_dataloader, data_scheduler_tracker, val_data_scheduler_tracker
+
+    print(f"Worker {fabric.global_rank} created dataloaders.")
+
+    if ret_dataloaders:
+        # Return the dataloaders and schedulers for further processing
+        return (
+            train_dataloader,
+            val_dataloader,
+            data_scheduler_tracker,
+            val_data_scheduler_tracker,
+        )
+
+    if iterate_k_steps is not None:
+        # simulate one step of the train dataloader draw
+        train_iterator = iter(train_dataloader)
+
+        for step in tqdm(range(iterate_k_steps), total=iterate_k_steps, desc=f"Worker {fabric.global_rank} iterating"):
+
+            data_batch = next(train_iterator)
+            input_ids, labels, metadata = data_batch
+
+            if step < 3 and fabric.global_rank % int(os.environ["SLURM_NTASKS_PER_NODE"]) == 0:
+                # Print the first few batches for inspection
+                # and only from the "first worker on each node"
+                print(
+                    f"Worker {fabric.global_rank} processed step {step + 1}/{iterate_k_steps} with input_ids shape: {input_ids.shape}, "
+                    f"labels shape: {labels.shape}, metadata: {metadata}, input_ids[:,:10]: {input_ids[:,:10]}"
+                )
+
+    # the final op we'll allow is to construct a hf dataset from a generator wrapped around the dataloader
+    # and then save it to parquet.
+    # we'll point the ds cache directly into the output directory and also save the parquet version there
+    if save_k_steps_to_parquet is not None:
+
+        def k_step_generator(dataloader, k_steps):
+            """Generator to yield k steps from the dataloader."""
+            train_iterator = iter(dataloader)
+            for step in tqdm(range(k_steps), total=k_steps, desc=f"Worker {fabric.global_rank} converting to dataset"):
+                data_batch = next(train_iterator)
+                input_ids, labels, metadata = data_batch
+                for i in range(input_ids.shape[0]):
+                    yield {
+                        "input_ids": input_ids[i],
+                    }
+
+        # Create a Dataset from the generator
+        gen_partial = partial(
+            k_step_generator,
+            dataloader=train_dataloader,
+            k_steps=save_k_steps_to_parquet,
+        )
+
+        cache_dir = f"{os.environ['OUTPUT_DIR']}/cache_{fabric.global_rank}"
+        os.makedirs(cache_dir, exist_ok=True)
+
+        dataset = Dataset.from_generator(gen_partial, cache_dir=cache_dir, num_proc=1)
+
+        # Save the dataset to parquet
+        output_dir = f'{os.environ["OUTPUT_DIR"]}/parquet'
+        os.makedirs(output_dir, exist_ok=True)
+        output_path = f"{output_dir}/worker_{fabric.global_rank:03d}-of-{fabric.world_size:03d}_ordered_dataset.parquet"
+        print(f"Worker {fabric.global_rank} saving dataset to {output_path}...")
+
+        # Optionally allow sharding the dataset into multiple files
+        if PARQUET_SHARDS is None:
+            dataset.to_parquet(output_path)
+        else:
+            for i in range(PARQUET_SHARDS):
+                shard_output_path = f"{output_dir}/ordered_dataset_shard_{i:03d}-of-{PARQUET_SHARDS:03d}.parquet"
+                print(f"Worker {fabric.global_rank} saving shard {i} to {shard_output_path}...")
+                dataset.shard(num_shards=PARQUET_SHARDS, index=i).to_parquet(shard_output_path)
+
+        # clear the cache dir for this worker after saving
+        shutil.rmtree(cache_dir)
+
+    success = True  # Simulate success or failure of dataset preparation
+
+    return success
+
+
+def main():
+    """Encapsulates main scope away from import calls."""
+
+    # Configuration loader
+    cfg: CLISettings = CLI(CLISettings)  # type: ignore
+
+    if cfg.max_steps is None:
+        cfg.max_tokens_per_device = cfg.max_tokens // cfg.WORLD_SIZE
+        cfg.tokens_per_step = cfg.micro_batch_size * cfg.block_size
+        cfg.max_steps = cfg.max_tokens_per_device // cfg.tokens_per_step
+
+        print(
+            f"Computed max steps: {cfg.max_steps} based on max tokens {cfg.max_tokens} and micro batch size {cfg.micro_batch_size}."
+        )
+    else:
+        print(f"Using provided max steps: {cfg.max_steps}.")
+
+    tokenizer = Tokenizer(cfg.tokenizer_path)
+    if tokenizer.pad_id is None:
+        tokenizer.pad_id = -1
+
+    # before we start the pool, we run one instance of the worker function just to get the filenames
+    # as we'll need to pass those to the workers instead of using a distributed broadcast.
+    train_filenames, val_filenames, _, _ = materialize_worker_dataset(
+        worker_id=0,
+        total_workers=cfg.WORLD_SIZE,
+        cfg=cfg,
+        tokenizer=tokenizer,
+        get_filenames_only=True,
+    )
+    print(f"Got {len(train_filenames)} total train files and {len(val_filenames)} total val files.")
+
+    # Simulate distributed env using multiprocessing pool
+    pool_size = min(NUM_PROC, cfg.WORLD_SIZE)
+    with Pool(processes=pool_size) as pool:
+        print(f"Starting a pool of {pool_size} workers to mock a dist world size of {cfg.WORLD_SIZE}.")
+        # Prepare the worker function with the config
+        worker_func = partial(
+            materialize_worker_dataset,
+            total_workers=cfg.WORLD_SIZE,
+            cfg=cfg,
+            tokenizer=tokenizer,
+            train_filenames=train_filenames,
+            val_filenames=val_filenames,
+            get_filenames_only=False,  # we want to actually process the data
+            ret_dataloaders=False,  # we don't need the dataloaders back in
+            iterate_k_steps=None,
+            # iterate_k_steps=10_000, # iterate over the dataloader for k steps
+            # iterate_k_steps=cfg.max_steps,
+            # save_k_steps_to_parquet=None,
+            # save_k_steps_to_parquet=10_000,  # save the dataset to parquet after k steps
+            save_k_steps_to_parquet=cfg.max_steps,
+        )
+
+        # Map the worker function to each worker ID and print results
+        results = pool.map(worker_func, range(cfg.WORLD_SIZE))
+
+    # Print results for each worker
+    for worker_id, success in enumerate(results):
+        if success:
+            print(f"Worker {worker_id} completed successfully.")
+        else:
+            print(f"Worker {worker_id} failed to prepare dataset.")
+
+
+if __name__ == "__main__":
+    main()