Add files using upload-large-folder tool

playground/Abbie-h100/old/trainer/dense_trainer.py

@@ -0,0 +1,325 @@
+import os
+
+import time
+from datetime import timedelta
+
+from typing import Optional
+from contextlib import nullcontext
+
+import torch
+import torch.distributed as dist
+
+from einops import rearrange
+
+from checkpoint.gargantua_ckpt import DenseCheckpointer
+from dualpipe.log import WandbLogger
+
+from dualpipe.module.shared.loss import preprocess_labels, criterion
+from trainer.cli import parse_args
+from trainer.helper import resume_from_sahara_ckpt
+from trainer.utils import (
+    load_config,
+    make_handler,
+    collect_scalars_across_data_parallel_group
+)
+
+# set_deterministic(42, False)
+
+from dualpipe.module.shared.vocab import vocab_parallel_cross_entropy
+from dualpipe.module.trainer_builder import build_dense_trainer
+
+_DEFAULT_LOCAL_DIR = '/opt/tiger/Abbie/profiles'
+
+
+class DenseTrainer:
+    def __init__(self, rank, local_rank, world_size, args):
+        print(f"Loading from path: {args.model}")
+        cfg = load_config(args.model)
+        self.rank = rank
+        self.local_rank = local_rank
+        self.world_size = world_size
+        self.args = args
+        self.cfg = cfg
+
+    def start(self):
+        assert self.args.pp_size >= 1, 'pp_size shall be true positive value'
+        # override checking
+        inner = self.args.inner if self.args.inner is not None else self.cfg.inner
+        layer_number = self.args.layer_number if self.args.layer_number is not None else self.cfg.layer_number
+        attention_dropout = self.args.attention_dropout if self.args.attention_dropout is not None else self.cfg.attention_dropout
+        residual_dropout = self.args.residual_dropout if self.args.residual_dropout is not None else self.cfg.residual_dropout
+        
+        if self.args.enable_profiler:
+            assert self.args.profiler_step is not None and self.args.profiler_step > 0, \
+                'Setting up profiler without profiler step is not allowed'
+        self._do_start(            
+            self.rank, self.local_rank, self.world_size,
+            experiment_name=self.args.trial_name,
+            train_home_path=self.args.train_home_path,
+            pp_size = self.args.pp_size,
+            tokenizer_path=self.args.tokenizer,
+            pad_idx = self.args.pad_idx,
+            vocab_size = self.args.vocab_size,
+            train_dataset = self.args.train_dataset,
+            train_size = self.args.train_size,
+            warmup_batch_ratio = self.args.warmup_batch_ratio,
+            seq_len = self.args.max_seq_len,
+            max_position_embeddings = self.args.max_position_embeddings,
+            stride = self.args.stride,
+            resume_ckpt_path = None,
+            resume_ckpt_step=self.args.resume_ckpt_step,
+            gbs = self.args.global_batch_size, 
+            micro_batch_size = self.args.micro_batch_size,
+            layer_number = layer_number,
+            hidden_size=self.cfg.hidden_size,
+            inner=inner,
+            num_attention_head = self.cfg.num_attention_head,
+            num_shared_qheads=self.args.num_shared_qheads,
+            attention_dropout = attention_dropout,
+            residual_dropout = residual_dropout,
+            lr_max=self.args.lr_max,
+            lr_min=self.args.lr_min,
+            lr_weight_decay=self.args.lr_weight_decay,
+            lr_warmup_step_rate=self.args.lr_warmup_step_rate,
+            enable_profiler = self.args.enable_profiler,
+            profiler_step = self.args.profiler_step,
+            ckpt_every_n_step = self.args.ckpt_every_n_step,
+            resume_from_sahara = self.args.resume_from_sahara)
+
+    def _do_start(self,
+                  rank, local_rank, world_size,
+                  experiment_name, train_home_path,
+                  pp_size: int,
+                  tokenizer_path: str, pad_idx: int,
+                  vocab_size: int, train_dataset: str, train_size: int, warmup_batch_ratio: float,
+                  seq_len: int, max_position_embeddings: int, stride: int,
+                  resume_ckpt_path: Optional[str], resume_ckpt_step: Optional[int],
+                  gbs: int, micro_batch_size: int,
+                  layer_number: int,
+                  hidden_size: int, inner: int, num_attention_head: int, num_shared_qheads: Optional[int],
+                  attention_dropout: float, residual_dropout: float,
+                  lr_max: float, lr_min: float, lr_weight_decay: float, lr_warmup_step_rate: float,
+                  enable_profiler: bool, profiler_step: Optional[int], ckpt_every_n_step: Optional[int], resume_from_sahara: Optional[str]):
+        epoch = 1
+        # set_deterministic(1234, False)
+        torch.manual_seed(1234)
+
+        assert world_size % pp_size == 0
+        assert gbs % micro_batch_size == 0, "global_batch_size shall be able to be divide up by micro_batch_size"
+        dp_size = world_size // pp_size
+        gbs = gbs // dp_size
+
+        dist.init_process_group(backend='nccl', init_method="env://", world_size=world_size, rank=rank)
+        print(f"[Rank-{rank}] caliberating gbs to {gbs}, dp to {dp_size}, ")
+
+        device = f'cuda:{local_rank}'
+        dtype = torch.bfloat16
+
+        db_logger = WandbLogger(rank, None, experiment_name)
+        group = dist.distributed_c10d._get_default_group()
+        world_size = group.size()
+
+        rank_generator, layer, train_dataloader, optimizers = build_dense_trainer(
+            rank=rank, local_rank=local_rank, world_size=world_size,
+            epoch_number=epoch,
+            train_path=train_dataset, train_size=train_size, 
+            val_path="invalid", val_size=-1, # TODO [yuyifeng.oscar] pending for validation integration        
+            warmup_step_rate=warmup_batch_ratio,
+            tokenizer_path=tokenizer_path, pad_idx=pad_idx,
+            global_batch_size=gbs, micro_batch_size=micro_batch_size,
+            max_seqlen=seq_len, max_position_embeddings=max_position_embeddings, stride=stride,
+            lr_max=lr_max, lr_min=lr_min, weight_decay=lr_weight_decay, lr_warmup_step_rate=lr_warmup_step_rate,
+            dp_size=dp_size, pp_size=pp_size,
+            layer_number=layer_number, vocab_size=vocab_size, hidden_size=hidden_size, inner=inner,
+            num_attention_head=num_attention_head, num_shared_qheads=num_shared_qheads,
+            attention_dropout=attention_dropout, residual_dropout=residual_dropout,
+            is_deterministic=True,
+        )
+
+        checkpointer = DenseCheckpointer(trial_name=experiment_name, trial_path=train_home_path, ranker=rank_generator)
+
+        if resume_ckpt_step is not None:
+            print(f"[Rank-{rank}] Resuming from step: {resume_ckpt_step}")
+            if pp_size > 1:
+                layers = layer.module
+            else:
+                layers = [layer]
+            checkpointer.load(layers, train_dataloader, optimizers, resume_ckpt_step)            
+
+        total_step = resume_ckpt_step if resume_ckpt_step is not None else 0
+        db_logger.set_step(total_step)
+        profiler_end_step = profiler_step + 10
+        if enable_profiler > 0:
+            prof = torch.profiler.profile(
+                schedule=torch.profiler.schedule(wait=profiler_step, warmup=2, active=1, repeat=0),
+                on_trace_ready=make_handler(rank, _DEFAULT_LOCAL_DIR),
+                record_shapes=True,
+                profile_memory=True,
+                with_modules=True,
+                with_stack=int(torch.__version__[0]) >= 2)
+        else:
+            prof = nullcontext()
+        train_dataloader_iter = iter(train_dataloader)
+
+        if resume_from_sahara is not None:
+            resume_from_sahara_ckpt(device, dtype, hidden_size, inner, layer, layer_number, optimizers, rank,
+                                         resume_from_sahara, vocab_size)
+
+        with prof:
+            for i in range(train_dataloader.length - total_step):
+                # for batches in train_dataloader_iter:
+                batches = next(train_dataloader)
+                start_time = time.perf_counter()
+                if pp_size == 1:
+                    losses = self._no_pp_step(layer, batches, device, gbs, micro_batch_size, hidden_size, rank_generator)
+                else:
+                    losses = self._pp_step(layer, batches, device, gbs, micro_batch_size, hidden_size, rank_generator)
+                if rank_generator.get_pp_rank() == 0:
+                    if pp_size > 1:
+                        losses = torch.cat(losses) * (gbs // micro_batch_size)
+                    loss_report = sum(losses) / len(losses)
+                    gather_objs = collect_scalars_across_data_parallel_group([loss_report], rank_generator.get_dp_group())
+                    gathered_loss = sum(gather_objs[0]) / dp_size
+                seen_token = (total_step * seq_len * micro_batch_size * gbs * world_size) / 1024.0 / 1024.0  # In M
+                optimizers.step()
+                end_time = time.perf_counter()
+                if rank == 0 and total_step % 1 == 0:
+                    caliberated_grad_norm = optimizers.grad_norm()
+                    remaining_step = (train_dataloader.length - total_step)
+                    seconds = (end_time - start_time)
+                    remaining_seconds = timedelta(seconds=(seconds * remaining_step))
+
+                    print(f"[Rank-{rank}] epoch step: {total_step} step_time: {seconds:.6f} ETA: {remaining_seconds} consumed: {seen_token}M tokens Loss: {gathered_loss} grad_norm: {caliberated_grad_norm} lr: {optimizers.get_last_lr()[0]:.3e}")
+                    db_logger.log_step({'training/loss': gathered_loss})
+                total_step += 1
+
+                if enable_profiler:                    
+                    if total_step == profiler_end_step:
+                        print("Ending profiler")
+                        prof.stop()
+                    if total_step < profiler_end_step:
+                        prof.step()
+                if ckpt_every_n_step is not None and total_step % ckpt_every_n_step == 0:
+                    if local_rank == 0:
+                        checkpointer.prepare_root(total_step)
+                    rank_generator.local_barrier()
+
+                    if pp_size > 1:
+                        layers = layer.module # Dualpipe
+                    else:
+                        layers = [layer] # Pure gargantua block.
+                    checkpointer.save(layers, train_dataloader, optimizers, total_step)
+
+        train_dataloader.terminate()
+        print("All done")
+
+    def _no_pp_step(self, model, batches, device, gbs, mbs, hidden_size, rank_generator):
+        losses = []
+        for batch in batches:
+            input_ids = batch['input_ids'].to(device=device)
+            cu_seqlen = batch['host_seqlens'].to(device=device)
+            word_idx = batch['word_idx'].to(device=device)
+            labels = batch['labels'].to(device=device)
+            loss_mask = batch['rmpad_loss_mask'].to(device=device)
+            input_ids = rearrange(input_ids, 'b s ... -> (b s) ...')
+            input_ids = input_ids[word_idx]
+            input_ids = input_ids.unsqueeze(0)
+            labels = labels.view(-1)[word_idx]
+            labels = labels.unsqueeze(0)
+            loss_mask[labels == 1] = 0
+            total_s = cu_seqlen[-1].item()
+            shift_labels = preprocess_labels(labels.squeeze(), cu_seqlen)
+            shift_labels.requires_grad = False
+            model.set_input_ctx((cu_seqlen, total_s))
+            # res = layer.forward(input_id, cu_seqlen, total_s)
+            res = model.forward(input_ids)
+            loss_arr = vocab_parallel_cross_entropy(res.float(), shift_labels).transpose(0, 1).contiguous()
+            loss_mask = loss_mask.view(-1).float().to(loss_arr.device)
+            loss_mean = torch.sum(loss_arr.view(-1) * loss_mask) / loss_mask.sum().clamp(min=1)
+            losses.append(loss_mean.detach().clone())
+            loss = loss_mean / (gbs // mbs)
+            loss.backward()
+        return losses
+
+
+    def _pp_step(self, model, batches, device, gbs, mbs, hidden_size, rank_generator):
+        losses = []
+        input_ids_arr = []
+        cu_seqlens_arr = []
+        inp_shapes_arr = []
+        total_ses_arr = []
+        labels_arr = []
+        loss_mask_arr = []
+        num_chunks = len(batches)
+        for b in batches:
+            # Commonly used by input_ids and labels.
+            word_idx = b['word_idx'].to(device=device)
+
+            # process input_ids
+            input_ids = b['input_ids'].to(device=device)
+            input_ids = rearrange(input_ids, 'b s ... -> (b s) ...')
+            input_ids = input_ids[word_idx]
+            input_ids = input_ids.unsqueeze(0)
+            input_ids_arr.append(input_ids)  # Appending
+
+            # process cu_seqlens & total_s
+            cu_seqlens = b['host_seqlens'].to(device=device)
+            cu_seqlens_arr.append(cu_seqlens)
+            total_s = cu_seqlens[-1].item()
+            total_ses_arr.append(total_s)
+
+            # process labels
+            labels = b['labels'].to(device=device)
+            labels = labels.view(-1)[word_idx]
+            labels = labels.unsqueeze(0)
+            labels_arr.append(labels)
+
+            # process loss_mask
+            loss_mask = b['rmpad_loss_mask'].to(device=device)
+            loss_mask[labels == 1] = 0
+            loss_mask_arr.append(loss_mask)
+
+            # input shapes.
+            inp_shape = (total_s, 1, hidden_size)
+            inp_shapes_arr.append(inp_shape)
+        if not rank_generator.is_first_rank():
+            hidden_states = [None for _ in range(num_chunks)]
+        else:
+            hidden_states = input_ids_arr
+        input_ctx = [(c, t, gbs // mbs) for c, t in zip(cu_seqlens_arr, total_ses_arr)]
+        loss, outputs = model.step(hidden_states, input_shapes=inp_shapes_arr, input_ctx=input_ctx,
+                                             num_chunks=num_chunks, criterion=criterion, labels=labels_arr,
+                                             return_outputs=False)
+        if rank_generator.is_first_rank():
+            losses.append(loss)
+            # res = layer.forward(input_ids)
+            # sample_check_pow2_grad(dict(layer.named_parameters()))
+        return losses
+
+
+# Example command line:
+'''
+NCCL_DEBUG=WARN MASTER_ADDR=$ARNOLD_WORKER_0_HOST MASTER_PORT=$ARNOLD_WORKER_0_PORT torchrun \
+--node_rank=$ARNOLD_ID --nproc_per_node=8 --nnodes=1 --rdzv_endpoint=$ARNOLD_WORKER_0_HOST:$ARNOLD_WORKER_0_PORT \
+/opt/tiger/Abbie/trainer/dense_trainer.py \
+--model=1b2.yaml \
+--trial_name=abbie_dense_1b2_1T_gbs128_gargantua_nopp_ckpt_UT1_b1 \
+--train_home_path=hdfs://harunava/home/byte_tteng_llm/users/yuyifeng.oscar/pretrain \
+--train_dataset=hdfs://harunava/home/byte_tteng_llm/data/final_datasets/thoth_v3.5_8T_1127_mix34/a6dac3f1/train \
+--train_size=1000000000000 \
+--tokenizer=hdfs://harunava/home/byte_tteng_llm/user/thoth/tokenizer/bbpe-136k-ml-1227 \
+--pad_idx=1 --vocab_size=136064 \
+--global_batch_size=128 --micro_batch_size=1 --warmup_batch_ratio=0.005 \
+--max_seq_len=4096 --max_position_embeddings=4096 --stride=3840 \
+--lr_max=5e-4 --lr_min=5e-5 --lr_weight_decay=0.1 \
+--ckpt_every_n_step=2000
+'''
+
+if __name__ == "__main__":
+    rank = int(os.environ['RANK'])
+    local_rank = int(os.environ['LOCAL_RANK'])
+    world_size = int(os.environ['WORLD_SIZE'])
+    print(f"[INIT] rank: {rank} local_rank: {local_rank} world_size: {world_size}")
+    args = parse_args()
+    trainer = DenseTrainer(rank, local_rank, world_size, args)
+    trainer.start()

playground/Abbie-h100/old/trainer/gargantua2_trainer.py

@@ -0,0 +1,345 @@
+import os
+
+import time
+from datetime import timedelta
+
+from typing import Optional
+from contextlib import nullcontext
+
+import torch
+import torch.distributed as dist
+
+from einops import rearrange
+
+from checkpoint.gargantua_ckpt import Gargantua2Checkpointer
+from dualpipe.log import WandbLogger
+
+from dualpipe.module.shared.dist_clip_grads import dist_clip_grad_norm
+from dualpipe.module.shared.loss import preprocess_labels, criterion
+from trainer.cli import parse_args
+from trainer.helper import resume_from_sahara_ckpt
+from trainer.utils import (
+    make_handler,
+    collect_scalars_across_data_parallel_group
+)
+from dualpipe.module.trainer_builder import build_gargantua_2_trainer
+from dualpipe.module.shared.functional import get_cosine_schedule_with_warmup
+from dualpipe.module.shared.grad_sync import BucketGradientSyncer
+
+_DEFAULT_LOCAL_DIR = '/opt/tiger/Abbie/profiles'
+
+
+class Trainer:
+    def __init__(self, rank, local_rank, world_size, args):
+        print(f"Loading from path: {args.model}")
+        self.rank = rank
+        self.local_rank = local_rank
+        self.world_size = world_size
+        self.args = args
+
+    def start(self):
+        assert self.args.pp_size >= 1, 'pp_size shall be true positive value'
+
+        if self.args.enable_profiler:
+            assert self.args.profiler_step is not None and self.args.profiler_step > 0, \
+                'Setting up profiler without profiler step is not allowed'
+        self._do_start(
+            self.rank,
+            self.local_rank,
+            self.world_size,
+            experiment_name=self.args.trial_name,
+            train_home_path=self.args.train_home_path,
+            pp_size=self.args.pp_size,
+            ep_size=self.args.ep_size,
+            tokenizer_path=self.args.tokenizer,
+            # pad_idx = self.args.pad_idx,
+            # vocab_size = self.args.vocab_size,
+            train_dataset = self.args.train_dataset,
+            # train_size = self.args.train_size,
+            # warmup_batch_ratio = self.args.warmup_batch_ratio,
+            seq_len = self.args.max_seq_len,
+            # max_position_embeddings = self.args.max_position_embeddings,
+            # stride = self.args.stride,
+            # resume_ckpt_path = None,
+            # resume_ckpt_step=self.args.resume_ckpt_step,
+            gbs = self.args.global_batch_size,
+            micro_batch_size = self.args.micro_batch_size,
+            # layer_number = layer_number,
+            # hidden_size=self.cfg.hidden_size,
+            # inner=inner,
+            # num_attention_head = self.cfg.num_attention_head,
+            # num_shared_qheads=self.args.num_shared_qheads,
+            # attention_dropout = attention_dropout,
+            # residual_dropout = residual_dropout,
+            lr_max=self.args.lr_max,
+            lr_min=self.args.lr_min,
+            lr_weight_decay=self.args.lr_weight_decay,
+            lr_warmup_step_rate=self.args.lr_warmup_step_rate,
+            enable_profiler = self.args.enable_profiler,
+            profiler_step = self.args.profiler_step,
+            # ckpt_every_n_step = self.args.ckpt_every_n_step,
+            # resume_from_sahara = self.args.resume_from_sahara,
+            pretrained_hf_path=self.args.pretrained_hf_path,
+            vit_lr_max=self.args.vit_lr_max,
+            vit_lr_min=self.args.vit_lr_min,
+        )
+
+    def _do_start(
+        self,
+        rank,
+        local_rank,
+        world_size,
+        experiment_name,
+        train_home_path,
+        pp_size: int,
+        ep_size: int,
+        tokenizer_path: str,
+        # pad_idx: int,
+        # vocab_size: int,
+        train_dataset: str,
+        # train_size: int,
+        # warmup_batch_ratio: float,
+        seq_len: int,
+        # max_position_embeddings: int,
+        # stride: int,
+        # resume_ckpt_path: Optional[str],
+        # resume_ckpt_step: Optional[int],
+        gbs: int,
+        micro_batch_size: int,
+        # layer_number: int,
+        # hidden_size: int,
+        # inner: int,
+        # num_attention_head: int,
+        # num_shared_qheads: Optional[int],
+        # attention_dropout: float,
+        # residual_dropout: float,
+        lr_max: float,
+        lr_min: float,
+        lr_weight_decay: float,
+        lr_warmup_step_rate: float,
+        enable_profiler: bool,
+        profiler_step: Optional[int],
+        # ckpt_every_n_step: Optional[int],
+        # resume_from_sahara: Optional[str],
+        pretrained_hf_path: Optional[str] = None,
+        vit_lr_max: Optional[float] = None,
+        vit_lr_min: Optional[float] = None,
+    ):
+        epoch = 1
+        # set_deterministic(1234, False)
+        torch.manual_seed(1234)
+
+        assert world_size % pp_size == 0
+        assert gbs % micro_batch_size == 0, "global_batch_size shall be able to be divide up by micro_batch_size"
+        dp_size = world_size // pp_size
+        gbs = gbs // dp_size
+
+        device = f'cuda:{local_rank}'
+        dtype = torch.bfloat16
+
+        torch.cuda.set_device(device)
+        dist.init_process_group(
+            backend='nccl',
+            init_method="env://",
+            world_size=world_size,
+            rank=rank,
+            device_id=torch.device(device),
+        )
+        print(f"[Rank-{rank}] caliberating gbs to {gbs}, dp to {dp_size}, ")
+
+        db_logger = WandbLogger(rank, "thoth_dualpipe-mingrui.wang2", experiment_name)
+        group = dist.distributed_c10d._get_default_group()
+        world_size = group.size()
+
+        DMM, model, train_dataloader, optimizer = build_gargantua_2_trainer(
+            rank=rank,
+            world_size=world_size,
+            train_paths=train_dataset,
+            tokenizer_path=tokenizer_path,
+            global_batch_size=gbs,
+            micro_batch_size=micro_batch_size,
+            max_seqlen=seq_len,
+            lr_max=lr_max,
+            lr_min=lr_min,
+            weight_decay=lr_weight_decay,
+            lr_warmup_step_rate=lr_warmup_step_rate,
+            pp_size=pp_size,
+            ep_size=ep_size,
+            pretrained_hf_path=pretrained_hf_path,
+            vit_lr_max=vit_lr_max,
+            vit_lr_min=vit_lr_min,
+        )
+
+        if getattr(model, "visual", None) is not None:
+            model.visual.gradient_checkpointing_enable({"use_reentrant": False})
+
+        # checkpointer = Gargantua2Checkpointer(
+        #     trial_name=experiment_name,
+        #     trial_path=train_home_path,
+        #     DMM=DMM,
+        # )
+
+        resume_ckpt_step = None
+        if resume_ckpt_step is not None:
+            print(f"[Rank-{rank}] Resuming from step: {resume_ckpt_step}")
+            # Save this for later when we fix the arpeggio dataloader resume
+            raise NotImplementedError
+            # checkpointer.load(layers, train_dataloader, optimizers, resume_ckpt_step)
+
+        total_step = resume_ckpt_step if resume_ckpt_step is not None else 0
+        db_logger.set_step(total_step)
+        profiler_end_step = profiler_step + 10
+        if enable_profiler > 0:
+            prof = torch.profiler.profile(
+                schedule=torch.profiler.schedule(wait=profiler_step, warmup=2, active=1, repeat=0),
+                on_trace_ready=make_handler(rank, _DEFAULT_LOCAL_DIR),
+                record_shapes=True,
+                profile_memory=True,
+                with_modules=True,
+                with_stack=int(torch.__version__[0]) >= 2)
+        else:
+            prof = nullcontext()
+
+        # if resume_from_sahara is not None:
+        #     resume_from_sahara_ckpt(device, dtype, hidden_size, inner, layer, layer_number, optimizers, rank,
+        #                                  resume_from_sahara, vocab_size)
+
+        with prof:
+            for batch in train_dataloader:
+                start_time = time.time()
+
+                batch.to(torch.bfloat16).to("cuda")
+
+                optimizer.zero_grad()
+                outputs = model.step(
+                    input_ids=batch["input_ids"],
+                    attention_mask=batch["attention_mask"],
+                    position_ids=batch["position_ids"],
+                    labels=batch["labels"],
+                    return_outputs=True,
+                    pixel_values=batch.get("pixel_values"),
+                    image_grid_thw=batch.get("image_grid_thw"),
+                    pixel_values_videos=batch.get("pixel_values_videos"),
+                    video_grid_thw=batch.get("video_grid_thw"),
+                )
+
+                # This sync is only to calculate optimizer time more accurately
+                # the training still works and can probably be slightly faster without this
+                torch.cuda.synchronize()
+                dist.barrier()
+
+                opt_start_time = time.time()
+                optimizer.step()
+                opt_end_time = time.time()
+
+                n_tokens = batch["attention_mask"].sum().item()
+                n_tokens = sum(all_gather_objects(n_tokens))
+
+                loss = 0
+                if outputs.loss is not None:
+                    loss = outputs.loss.sum().item()
+                loss = sum(all_gather_objects(loss))
+
+                end_time = time.time()
+
+                if rank == 0:
+                    # caliberated_grad_norm = optimizers.grad_norm()
+                    # caliberated_grad_norm = 0
+                    remaining_step = (len(train_dataloader) - total_step)
+                    seconds = end_time - start_time
+                    remaining_seconds = timedelta(seconds=seconds * remaining_step)
+
+                    metrics = {
+                        "training/loss": loss,
+                        "train/loss": loss,
+                        # "train/grad_norm": grad_norm,
+                        "data/tokens_per_step": n_tokens,
+                        # "train/lr": optimizer.get_last_lr(),
+                        "perf/optim_time": opt_end_time - opt_start_time,
+                        "perf/max_memory_allocated": torch.cuda.max_memory_allocated(),
+                        "perf/max_memory_reserved": torch.cuda.max_memory_reserved(),
+                    }
+                    for name, lr in optimizer.last_lr.items():
+                        metrics[f"train/{name}_lr"] = lr
+
+                    grad_norms = optimizer.last_grad_norm
+                    for name, grad_norm in grad_norms.items():
+                        metrics[f"train/{name}_grad_norm"] = grad_norm
+                    metrics["train/grad_norm"] = grad_norms["llm"]
+
+                    db_logger.log_step(metrics)
+                    print(f"[Rank-{rank}] epoch step: {total_step} step_time: {seconds:.6f} ETA: {remaining_seconds} n_tokens: {n_tokens} tokens Loss: {loss} grad_norm: {grad_norm}")
+                total_step += 1
+
+                if enable_profiler:
+                    if total_step == profiler_end_step:
+                        print("Ending profiler")
+                        prof.stop()
+                    if total_step < profiler_end_step:
+                        prof.step()
+
+                # if total_step >= 10:
+                #     break
+
+                # For now skip checkpoint
+                # if ckpt_every_n_step is not None and total_step % ckpt_every_n_step == 0:
+                #     if local_rank == 0:
+                #         checkpointer.prepare_root(total_step)
+                #     rank_generator.local_barrier()
+
+                #     if pp_size > 1:
+                #         layers = layer.module # Dualpipe
+                #     else:
+                #         layers = [layer] # Pure gargantua block.
+                #     checkpointer.save(layers, train_dataloader, optimizers, total_step)
+
+        # train_dataloader.terminate()
+        print("All done")
+
+
+def all_gather_objects(value, group: Optional[dist.ProcessGroup] = None):
+    if not dist.is_initialized():
+        return [value]
+
+    if group is None:
+        group = dist.group.WORLD
+
+    values = [None for _ in range(group.size())]
+    dist.all_gather_object(
+        object_list=values,
+        obj=value,
+        group=group,
+    )
+    return values
+
+
+# Example command line:
+'''
+NCCL_DEBUG=WARN MASTER_ADDR=$ARNOLD_WORKER_0_HOST MASTER_PORT=$ARNOLD_WORKER_0_PORT torchrun \
+--node_rank=$ARNOLD_ID --nproc_per_node=8 --nnodes=1 --rdzv_endpoint=$ARNOLD_WORKER_0_HOST:$ARNOLD_WORKER_0_PORT \
+/opt/tiger/Abbie/trainer/dense_trainer.py \
+--model=1b2.yaml \
+--trial_name=abbie_dense_1b2_1T_gbs128_gargantua_nopp_ckpt_UT1_b1 \
+--train_home_path=hdfs://harunava/home/byte_tteng_llm/users/yuyifeng.oscar/pretrain \
+--train_dataset=hdfs://harunava/home/byte_tteng_llm/data/final_datasets/thoth_v3.5_8T_1127_mix34/a6dac3f1/train \
+--train_size=1000000000000 \
+--tokenizer=hdfs://harunava/home/byte_tteng_llm/user/thoth/tokenizer/bbpe-136k-ml-1227 \
+--pad_idx=1 --vocab_size=136064 \
+--global_batch_size=128 --micro_batch_size=1 --warmup_batch_ratio=0.005 \
+--max_seq_len=4096 --max_position_embeddings=4096 --stride=3840 \
+--lr_max=5e-4 --lr_min=5e-5 --lr_weight_decay=0.1 \
+--ckpt_every_n_step=2000
+'''
+
+if __name__ == "__main__":
+    rank = int(os.environ['RANK'])
+    local_rank = int(os.environ['LOCAL_RANK'])
+    world_size = int(os.environ['WORLD_SIZE'])
+    print(f"[INIT] rank: {rank} local_rank: {local_rank} world_size: {world_size}")
+    args = parse_args()
+    # if local_rank == 0:
+    #     torch.cuda.memory._record_memory_history()
+    trainer = Trainer(rank, local_rank, world_size, args)
+    trainer.start()
+    # if local_rank == 0:
+    #     torch.cuda.memory._dump_snapshot("memory_snapshot.pkl")

playground/Abbie-h100/old/trainer/helper.py

@@ -0,0 +1,57 @@
+import torch
+
+
+def _extract_weights(resume_from_path, rank, vocab_size, hidden_size, inner_size, dtype, device, layer_number):
+    vocab_embedding = torch.nn.Linear(hidden_size, vocab_size, dtype=dtype, device=device)
+    logits_embedding = torch.nn.Linear(hidden_size, vocab_size, dtype=dtype, device=device)
+    final_rms_norm_weight = torch.ones(hidden_size, dtype=dtype, device=device)
+    qkv = [torch.nn.Linear(hidden_size, hidden_size * 3, bias=False, dtype=dtype, device=device) for _ in
+           range(layer_number)]
+    dense = [torch.nn.Linear(hidden_size, hidden_size, bias=False, dtype=dtype, device=device) for _ in
+             range(layer_number)]
+    w1 = [torch.nn.Linear(hidden_size, 2 * inner_size, bias=False, dtype=dtype, device=device) for _ in
+          range(layer_number)]
+    w2 = [torch.nn.Linear(inner_size, hidden_size, bias=False, dtype=dtype, device=device) for _ in
+          range(layer_number)]
+    qkv_rmsnorm_weight = [torch.ones(hidden_size, dtype=dtype, device=device) for _ in range(layer_number)]
+    rmsnorm_weight = [torch.ones(hidden_size, dtype=dtype, device=device) for _ in range(layer_number)]
+
+    WEIGHT_PATH=f'{resume_from_path}/rank{rank}'
+    print(f"Loading from path: {WEIGHT_PATH}")
+    vocab_weight = torch.load(f'{WEIGHT_PATH}/vocab_weight.pt').to(device=device)
+    vocab_embedding.weight.data.copy_(vocab_weight.data)
+
+    for i in range(layer_number):
+        qkv_dump = torch.load(f'{WEIGHT_PATH}/layers.{i}.self_attention.query_key_value.weight.pt').to(device=device)
+        qkv[i].weight.data.copy_(qkv_dump.data)
+        dense_dump = torch.load(f'{WEIGHT_PATH}/layers.{i}.self_attention.dense.weight.pt').to(device=device)
+        dense[i].weight.data.copy_(dense_dump.data)
+        w1_dump = torch.load(f'{WEIGHT_PATH}/layers.{i}.mlp.fc1_weight.pt').to(device=device)
+        w1[i].weight.data.copy_(w1_dump.data)
+        w2_dump = torch.load(f'{WEIGHT_PATH}/layers.{i}.mlp.fc2_weight.pt').to(device=device)
+        w2[i].weight.data.copy_(w2_dump.data)
+    qkv_weights = [a.weight for a in qkv]
+    dense_weights = [a.weight for a in dense]
+    w1_weights = [a.weight for a in w1]
+    w2_weights = [a.weight for a in w2]
+    return vocab_embedding.weight, final_rms_norm_weight, logits_embedding.weight, qkv_weights, dense_weights, w1_weights, w2_weights, qkv_rmsnorm_weight, rmsnorm_weight
+
+def resume_from_sahara_ckpt(device, dtype, hidden_size, inner, layer, layer_number, optimizers, rank,
+                            resume_from_sahara, vocab_size):
+    (
+        vocab_weight,
+        final_rms_weight,
+        logits_weight,
+        qkv_weight,
+        dense_weight,
+        w1_weight,
+        w2_weight,
+        qkv_rmsnorm_weight,
+        rmsnorm_weight
+    ) = _extract_weights(resume_from_sahara, rank, vocab_size, hidden_size, inner, dtype, device, layer_number)
+    print(f"[rank-{rank}] setting weight ... ")
+    layer.set_weight(vocab_weight, final_rms_weight, logits_weight, qkv_weight, qkv_rmsnorm_weight, dense_weight,
+                     w1_weight,
+                     w2_weight, [], rmsnorm_weight)
+    for opt in optimizers.optimizers:
+        opt.reload_fp32_param_from_original()

playground/Abbie-h100/old/trainer/moe_trainer.py

@@ -0,0 +1,250 @@
+from typing import Optional
+
+import os
+
+import time
+from datetime import timedelta
+
+from typing import Optional
+from contextlib import nullcontext
+
+import torch
+import torch.distributed as dist
+
+from einops import rearrange
+
+from checkpoint.gargantua_ckpt import MoECheckpointer
+from dualpipe.log import WandbLogger
+from dualpipe.deterministic import set_deterministic
+
+from dualpipe.module.shared.loss import preprocess_labels, criterion
+from trainer.cli import parse_args
+from trainer.utils import (
+    load_config,
+    make_handler,
+    collect_scalars_across_data_parallel_group
+)
+
+set_deterministic(42, False)
+
+from dualpipe.module.shared.vocab import vocab_parallel_cross_entropy
+from dualpipe.module.trainer_builder import build_moe_trainer
+from trainer.dense_trainer import DenseTrainer
+
+_DEFAULT_LOCAL_DIR = '/opt/tiger/Abbie/profiles'
+
+
+class MoETrainer(DenseTrainer):
+    def __init__(self, rank, local_rank, world_size, args):
+        super().__init__(rank, local_rank, world_size, args)
+
+    def start(self):
+        assert self.args.pp_size >= 1, 'pp_size shall be true positive value'
+        # override checking
+        inner = self.args.inner if self.args.inner is not None else self.cfg.inner
+        layer_number = self.args.layer_number if self.args.layer_number is not None else self.cfg.layer_number
+        attention_dropout = self.args.attention_dropout if self.args.attention_dropout is not None else self.cfg.attention_dropout
+        residual_dropout = self.args.residual_dropout if self.args.residual_dropout is not None else self.cfg.residual_dropout
+
+        if self.args.enable_profiler:
+            assert self.args.profiler_step is not None and self.args.profiler_step > 0, \
+                'Setting up profiler without profiler step is not allowed'
+        self._do_start(            
+            self.rank, self.local_rank, self.world_size,
+            experiment_name=self.args.trial_name,
+            train_home_path=self.args.train_home_path,
+            pp_size = self.args.pp_size,
+            ep_size = self.args.ep_size,
+            tokenizer_path=self.args.tokenizer,
+            pad_idx = self.args.pad_idx,
+            vocab_size = self.args.vocab_size,
+            train_dataset = self.args.train_dataset,
+            train_size = self.args.train_size,
+            warmup_batch_ratio = self.args.warmup_batch_ratio,
+            seq_len = self.args.max_seq_len,
+            max_position_embeddings = self.args.max_position_embeddings,
+            stride = self.args.stride,
+            resume_ckpt_path = None,
+            resume_ckpt_step=self.args.resume_ckpt_step,
+            gbs = self.args.global_batch_size, micro_batch_size = self.args.micro_batch_size,
+            layer_number = layer_number,
+            hidden_size=self.cfg.hidden_size,
+            inner=inner,
+            num_attention_head =self.cfg.num_attention_head,
+            num_shared_qheads=self.args.num_shared_qheads,
+            is_tie_weight=self.cfg.is_tie_weight,
+            attention_dropout=attention_dropout,
+            residual_dropout=residual_dropout,
+            expert_num=self.cfg.expert_number,
+            top_k=self.cfg.num_experts_per_tok,
+            lr_max=self.args.lr_max,
+            lr_min=self.args.lr_min,
+            lr_weight_decay=self.args.lr_weight_decay,
+            enable_profiler = self.args.enable_profiler,
+            profiler_step = self.args.profiler_step,
+            ckpt_every_n_step = self.args.ckpt_every_n_step)
+
+    def _do_start(self,
+                  rank, local_rank, world_size,
+                  experiment_name, train_home_path,
+                  pp_size: int,
+                  ep_size: int,
+                  tokenizer_path: str, pad_idx: int,
+                  vocab_size: int, train_dataset: str, train_size: int, warmup_batch_ratio: float,
+                  seq_len: int, max_position_embeddings: int, stride: int,
+                  resume_ckpt_path: Optional[str], resume_ckpt_step: Optional[int],
+                  gbs: int, micro_batch_size: int,
+                  layer_number: int,
+                  hidden_size: int, inner: int, num_attention_head: int, num_shared_qheads: Optional[int],
+                  expert_num: int, top_k: int, is_tie_weight: bool,
+                  attention_dropout: float, residual_dropout: float,
+                  lr_max: float, lr_min: float, lr_weight_decay: float,
+                  enable_profiler: bool, profiler_step: Optional[int], ckpt_every_n_step: Optional[int]):
+        epoch = 1
+        set_deterministic(42, False)
+
+        assert world_size % pp_size == 0
+        dp_size = world_size // pp_size
+        gbs = gbs // dp_size
+
+        dist.init_process_group(backend='nccl', init_method="env://", world_size=world_size, rank=rank)
+        print(f"[Rank-{rank}] caliberating gbs to {gbs}, dp to {dp_size}, ")
+
+        device = f'cuda:{local_rank}'
+        dtype = torch.bfloat16
+
+        db_logger = WandbLogger(rank, None, experiment_name)
+        group = dist.distributed_c10d._get_default_group()
+        world_size = group.size()
+
+        rank_generator, layer, train_dataloader, optimizers = build_moe_trainer(
+            rank=rank, local_rank=local_rank, world_size=world_size,
+            epoch_number=epoch,
+            train_path=train_dataset, train_size=train_size, 
+            val_path="invalid", val_size=-1, # TODO [yuyifeng.oscar] pending for validation integration        
+            warmup_step_rate=warmup_batch_ratio,
+            tokenizer_path=tokenizer_path, pad_idx=pad_idx,
+            global_batch_size=gbs, micro_batch_size=micro_batch_size,
+            max_seqlen=seq_len, max_position_embeddings=max_position_embeddings, stride=stride,
+            lr_max=lr_max, lr_min=lr_min, weight_decay=lr_weight_decay,
+            dp_size=dp_size, pp_size=pp_size, ep_size=ep_size,
+            expert_size=inner, expert_num=expert_num, top_k=top_k, is_tie_weight=is_tie_weight,
+            layer_number=layer_number, vocab_size=vocab_size, hidden_size=hidden_size,
+            num_attention_head=num_attention_head, num_shared_qheads=num_shared_qheads,
+            attention_dropout=attention_dropout, residual_dropout=residual_dropout,
+            is_deterministic=True,
+        )
+
+        checkpointer = MoECheckpointer(trial_name=experiment_name, trial_path=train_home_path, ranker=rank_generator)
+        if rank == 0:
+            checkpointer.save_recipes(self.recipes())
+
+        if resume_ckpt_step is not None:
+            print(f"[Rank-{rank}] Resuming from step: {resume_ckpt_step}")
+            if pp_size > 1:
+                layers = layer.module
+            else:
+                layers = [layer]
+            checkpointer.load(layers, train_dataloader, optimizers, resume_ckpt_step)            
+
+        total_step = resume_ckpt_step if resume_ckpt_step is not None else 0
+        db_logger.set_step(total_step)
+        profiler_end_step = profiler_step + 10
+        if enable_profiler > 0:
+            prof = torch.profiler.profile(
+                schedule=torch.profiler.schedule(wait=profiler_step, warmup=2, active=1, repeat=0),
+                on_trace_ready=make_handler(rank, _DEFAULT_LOCAL_DIR),
+                record_shapes=True,
+                profile_memory=True,
+                with_modules=True,
+                with_stack=int(torch.__version__[0]) >= 2)
+        else:
+            prof = nullcontext()
+        train_dataloader_iter = iter(train_dataloader)
+        with prof:
+            for i in range(train_dataloader.length - total_step):
+                # for batches in train_dataloader_iter:
+                batches = next(train_dataloader)
+                start_time = time.perf_counter()
+                if pp_size == 1:
+                    losses = self._no_pp_step(layer, batches, device, gbs, micro_batch_size, hidden_size, rank_generator)
+                else:
+                    losses = self._pp_step(layer, batches, device, gbs, micro_batch_size, hidden_size, rank_generator)
+                if rank_generator.get_pp_rank() == 0:
+                    if pp_size > 1:
+                        losses = torch.cat(losses) * gbs
+                    loss_report = sum(losses) / len(losses)
+                    gather_objs = collect_scalars_across_data_parallel_group([loss_report], rank_generator.get_dp_group())
+                    gathered_loss = sum(gather_objs[0]) / dp_size
+                seen_token = (total_step * seq_len * micro_batch_size * gbs * world_size) / 1024.0 / 1024.0  # In M
+                optimizers.step()
+                end_time = time.perf_counter()
+                if rank == 0 and total_step % 1 == 0:
+                    caliberated_grad_norm = optimizers.grad_norm()
+                    remaining_step = (train_dataloader.length - total_step)
+                    seconds = (end_time - start_time)
+                    remaining_seconds = timedelta(seconds=(seconds * remaining_step))
+
+                    print(f"[Rank-{rank}] epoch step: {total_step} step_time: {seconds:.6f} ETA: {remaining_seconds} consumed: {seen_token}M tokens Loss: {gathered_loss} grad_norm: {caliberated_grad_norm} lr: {optimizers.get_last_lr()[0]:.3e}")
+                    db_logger.log_step({
+                                            'training/loss': gathered_loss, 
+                                            'training/lr': optimizers.get_last_lr()[0],
+                                            'training/grad_norm': caliberated_grad_norm,
+                                            'consumed_tokens': seen_token,
+                                        })
+                total_step += 1
+
+                if enable_profiler:                    
+                    if total_step == profiler_end_step:
+                        print("Ending profiler")
+                        prof.stop()
+                    if total_step < profiler_end_step:
+                        prof.step()
+                if ckpt_every_n_step is not None and total_step % ckpt_every_n_step == 0:
+                    if local_rank == 0:
+                        checkpointer.prepare_root(total_step)
+                    rank_generator.local_barrier()
+
+                    if pp_size > 1:
+                        layers = layer.module # Dualpipe
+                    else:
+                        layers = [layer] # Pure gargantua block.
+                    checkpointer.save(layers, train_dataloader, optimizers, total_step)
+
+        train_dataloader.terminate()
+        print("All done")
+
+    def recipes(self):
+        cfg_dict = vars(self.cfg)
+        args_dict = vars(self.args)
+        
+        return {**cfg_dict, **{k: v for k, v in args_dict.items() if v is not None}}
+
+
+# Example command line:
+'''
+NCCL_DEBUG=WARN MASTER_ADDR=$ARNOLD_WORKER_0_HOST MASTER_PORT=$ARNOLD_WORKER_0_PORT torchrun \
+--node_rank=$ARNOLD_ID --nproc_per_node=8 --nnodes=1 --rdzv_endpoint=$ARNOLD_WORKER_0_HOST:$ARNOLD_WORKER_0_PORT \
+/opt/tiger/Abbie/trainer/dense_trainer.py \
+--model=1b2.yaml \
+--trial_name=abbie_moe_1b2_1T_gbs128_gargantua_nopp_ckpt_UT1_b1 \
+--train_home_path=hdfs://harunava/home/byte_tteng_llm/users/yuyifeng.oscar/pretrain \
+--train_dataset=hdfs://harunava/home/byte_tteng_llm/data/final_datasets/thoth_v3.5_8T_1127_mix34/a6dac3f1/train \
+--train_size=1000000000000 \
+--tokenizer=hdfs://harunava/home/byte_tteng_llm/user/thoth/tokenizer/bbpe-136k-ml-1227 \
+--pad_idx=1 --vocab_size=136064 \
+--ep_size=2 \
+--global_batch_size=128 --micro_batch_size=1 --warmup_batch_ratio=0.005 \
+--max_seq_len=4096 --max_position_embeddings=4096 --stride=3840 \
+--lr_max=5e-4 --lr_min=5e-5 --lr_weight_decay=0.1 \
+--ckpt_every_n_step=2000
+'''
+
+if __name__ == "__main__":
+    rank = int(os.environ['RANK'])
+    local_rank = int(os.environ['LOCAL_RANK'])
+    world_size = int(os.environ['WORLD_SIZE'])
+    print(f"[INIT] rank: {rank} local_rank: {local_rank} world_size: {world_size}")
+    args = parse_args()
+    trainer = MoETrainer(rank, local_rank, world_size, args)
+    trainer.start()

playground/Abbie-h100/old/trainer/template/1b2.yaml

@@ -0,0 +1,6 @@
+hidden_size: 2048
+inner: 5504
+num_attention_head: 16
+layer_number: 24
+attention_dropout: 0.1
+residual_dropout: 0.1

playground/Abbie-h100/old/trainer/template/32b.yaml

@@ -0,0 +1,6 @@
+hidden_size: 6144
+inner: 15360
+num_attention_head: 48
+layer_number: 72
+attention_dropout: 0.0
+residual_dropout: 0.0

playground/Abbie-h100/old/trainer/template/93b.yaml

@@ -0,0 +1,6 @@
+hidden_size: 8192
+inner: 20480
+num_attention_head: 64
+layer_number: 108
+attention_dropout: 0.0
+residual_dropout: 0.0

playground/Abbie-h100/old/trainer/template/moe_30b.yaml

@@ -0,0 +1,9 @@
+hidden_size: 2048
+inner: 768
+num_attention_head: 32
+layer_number: 48
+expert_number: 128
+num_experts_per_tok: 8
+is_tie_weight: False
+attention_dropout: 0.0
+residual_dropout: 0.0

playground/Abbie-h100/old/trainer/utils.py

@@ -0,0 +1,45 @@
+import time
+import torch
+import os
+import yaml
+from types import SimpleNamespace
+
+def dict_to_namespace(d):
+    if isinstance(d, dict):
+        return SimpleNamespace(**{k: dict_to_namespace(v) for k, v in d.items()})
+    elif isinstance(d, list):
+        return [dict_to_namespace(i) for i in d]
+    else:
+        return d
+
+def load_config(path):
+    with open(f'/opt/tiger/Abbie/trainer/template/{path}', 'r') as f:
+        cfg_dict = yaml.safe_load(f)
+        return dict_to_namespace(cfg_dict)
+
+
+def make_handler(rank, local_dir):
+    def handler_fn(p):
+        # export trace data when traces ready (schedule cycle ends)
+        fname = "profileStep" + str(p.step_num) + "_globalStep" + str(0) + "_rank" + str(rank) + "." + \
+                str(int(time.time())) + ".pt.trace.json.gz"
+        local_file = os.path.join(local_dir, fname)
+        if not os.path.exists(local_dir):
+            print("mkdir ", local_dir)
+            os.makedirs(local_dir)
+        print("Save profile results to {}".format(local_file))
+        p.export_chrome_trace(local_file)
+        print("Local profile file saved")
+
+    return handler_fn
+
+
+def collect_scalars_across_data_parallel_group(scalars, dp_group):
+    """Reduce a tensor of losses across all GPUs."""
+    scalars = torch.cat(
+        [loss.clone().detach().view(1) for loss in scalars])
+    group_size = torch.distributed.get_world_size(group=dp_group)
+    out_scalars = [torch.ones_like(scalars) for i in range(group_size)]
+    torch.distributed.all_gather(out_scalars, scalars,
+                                 group=dp_group)
+    return out_scalars, group_size

playground/Abbie-h100/tests/bench_qwen2.py

@@ -0,0 +1,299 @@
+import argparse
+import os
+import time
+from functools import partial
+from typing import Tuple
+
+import torch
+from torch.utils.checkpoint import checkpoint, CheckpointPolicy, create_selective_checkpoint_contexts
+from transformers import Qwen2Config
+from transformers.models.qwen2.modeling_qwen2 import Qwen2DecoderLayer, Qwen2RotaryEmbedding
+
+from dualpipe.module.gargantua.models.qwen2 import Qwen2DecoderLayerFunc
+from dualpipe.utils import run_backward
+
+
+def make_config() -> Qwen2Config:
+    if True:
+        # Qwen2.5-72B configs
+        return Qwen2Config(
+            attention_dropout=0.0,
+            bos_token_id=151643,
+            eos_token_id=151645,
+            hidden_act="silu",
+            hidden_size=8192,
+            initializer_range=0.02,
+            intermediate_size=29568,
+            max_position_embeddings=32768,
+            max_window_layers=70,
+            num_attention_heads=64,
+            num_hidden_layers=80,
+            num_key_value_heads=8,
+            rms_norm_eps=1e-06,
+            rope_theta=1000000.0,
+            sliding_window=131072,
+            tie_word_embeddings=False,
+            torch_dtype="bfloat16",
+            use_cache=False,
+            use_sliding_window=False,
+            vocab_size=152064,
+            attn_implementation="flash_attention_2",
+        )
+
+    # Qwen2.5-7B configs
+    return Qwen2Config(
+        attention_dropout=0.0,
+        bos_token_id=151643,
+        eos_token_id=151645,
+        hidden_act="silu",
+        hidden_size=3584,
+        initializer_range=0.02,
+        intermediate_size=18944,
+        max_position_embeddings=32768,
+        max_window_layers=28,
+        num_attention_heads=28,
+        num_hidden_layers=28,
+        num_key_value_heads=4,
+        rms_norm_eps=1e-06,
+        rope_theta=1000000.0,
+        sliding_window=131072,
+        tie_word_embeddings=False,
+        torch_dtype="bfloat16",
+        use_cache=True,
+        use_sliding_window=False,
+        vocab_size=152064,
+        attn_implementation="flash_attention_2",
+    )
+
+
+def zero_grads(layer: Qwen2DecoderLayer):
+    for param in layer.parameters():
+        param.grad = None
+
+
+def bench_qwen2_decoder_layer_hf(
+    layer: Qwen2DecoderLayer,
+    input_tensor: torch.Tensor,
+    attention_mask: torch.Tensor,
+    position_ids: torch.Tensor,
+    position_embeddings: Tuple[torch.Tensor, torch.Tensor],
+    cu_seqlens: torch.Tensor,
+    max_seqlen: torch.Tensor,
+    d_output_tensor: torch.Tensor,
+    n_rounds: int = 6,
+    recompute: bool = False,
+    recompute_skip_attn: bool = False,
+):
+    forward_kwargs = dict(
+        hidden_states=input_tensor,
+        attention_mask=attention_mask,
+        position_ids=position_ids,
+        position_embeddings=position_embeddings,
+        cumulative_seqlens_q=cu_seqlens,
+        cumulative_seqlens_k=cu_seqlens,
+        max_length_q=max_seqlen,
+        max_length_k=max_seqlen,
+    )
+
+    if recompute:
+        compute_intensive_ops = []
+        if recompute_skip_attn:
+            # Based on past experience, saving attn output is the optimal
+            compute_intensive_ops = [
+                torch.ops.flash_attn._flash_attn_varlen_forward.default,
+            ]
+
+        def policy_fn(ctx, op, *args, **kwargs):
+            if op in compute_intensive_ops:
+                return CheckpointPolicy.MUST_SAVE
+            return CheckpointPolicy.PREFER_RECOMPUTE
+
+        context_fn = partial(create_selective_checkpoint_contexts, policy_fn)
+
+    for run_nb in range(n_rounds):
+        zero_grads(layer)
+        input_tensor.grad = None
+
+        torch.cuda.synchronize()
+        start_time = time.time()
+
+        mem_a_gb = torch.cuda.memory_allocated() / (1 << 30)
+        print(f"before fwd {mem_a_gb=:.2f}GB")
+
+        if recompute:
+            output_tensor = checkpoint(
+                layer,
+                use_reentrant=False,
+                context_fn=context_fn,
+                **forward_kwargs,
+            )
+
+        else:
+            output_tensor = layer(**forward_kwargs)
+
+        mem_a_gb = torch.cuda.memory_allocated() / (1 << 30)
+        print(f"after fwd {mem_a_gb=:.2f}GB")
+
+        if isinstance(output_tensor, tuple):
+            output_tensor = output_tensor[0]
+        run_backward((output_tensor,), (d_output_tensor,))
+
+        mem_a_gb = torch.cuda.memory_allocated() / (1 << 30)
+        print(f"after bwd {mem_a_gb=:.2f}GB")
+
+        torch.cuda.synchronize()
+        finish_time = time.time()
+        time_taken = finish_time - start_time
+
+        mem_a_gb = torch.cuda.max_memory_allocated() / (1 << 30)
+        mem_r_gb = torch.cuda.max_memory_reserved() / (1 << 30)
+        if recompute:
+            ctx_size_gb = input_tensor.numel() * input_tensor.element_size() / (1 << 30)
+            print(f"{run_nb=} {time_taken=:.5f}s {mem_a_gb=:.2f}GB {mem_r_gb=:.2f}GB {ctx_size_gb=:.2f}GB")
+        else:
+            print(f"{run_nb=} {time_taken=:.5f}s {mem_a_gb=:.2f}GB {mem_r_gb=:.2f}GB")
+
+
+def bench_qwen2_decoder_layer_gargantua(
+    layer: Qwen2DecoderLayer,
+    input_tensor: torch.Tensor,
+    position_embeddings: Tuple[torch.Tensor, torch.Tensor],
+    cu_seqlens: torch.Tensor,
+    max_seqlen: torch.Tensor,
+    d_output_tensor: torch.Tensor,
+    recompute_rms_norm: bool = False,
+    recompute_qkv_proj: bool = False,
+    recompute_attn: bool = False,
+    recompute_mlp: bool = False,
+    recompute_silu: bool = False,
+    n_rounds: int = 10,
+):
+    for run_nb in range(n_rounds):
+        zero_grads(layer)
+        input_tensor.grad = None
+
+        torch.cuda.synchronize()
+        start_time = time.time()
+
+        output_tensor, ctx = Qwen2DecoderLayerFunc.apply_module(
+            layer=layer,
+            x=input_tensor,
+            cos=position_embeddings[0],
+            sin=position_embeddings[1],
+            cu_seqlens=cu_seqlens,
+            max_seqlen=max_seqlen,
+            recompute_rms_norm=recompute_rms_norm,
+            recompute_qkv_proj=recompute_qkv_proj,
+            recompute_attn=recompute_attn,
+            recompute_mlp=recompute_mlp,
+            recompute_silu=recompute_silu,
+        )
+        ctx_size_gb = ctx.calc_size() / (1 << 30)
+        run_backward((output_tensor,), (d_output_tensor,))
+
+        torch.cuda.synchronize()
+        finish_time = time.time()
+        time_taken = finish_time - start_time
+
+        mem_a_gb = torch.cuda.max_memory_allocated() / (1 << 30)
+        mem_r_gb = torch.cuda.max_memory_reserved() / (1 << 30)
+        print(f"{run_nb=} {time_taken=:.5f}s {mem_a_gb=:.2f}GB {mem_r_gb=:.2f}GB {ctx_size_gb=:.2f}GB")
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-s", "--seqlen", type=int, default=4 << 10)
+    parser.add_argument("-t", "--type", choices=["gargantua", "hf"], default="gargantua")
+    parser.add_argument(
+        "--deterministic",
+        action="store_true",
+        help="Use deterministic algo",
+    )
+    parser.add_argument(
+        "--compile",
+        action="store_true",
+        help="Compile layer (only effective for hf)",
+    )
+    parser.add_argument("--use_liger", action="store_true")
+    parser.add_argument("--activation_memory_budget", type=float, default=1.0)
+    parser.add_argument("--recompute_hf", action="store_true")
+    parser.add_argument("--recompute_hf_skip_attn", action="store_true")
+    parser.add_argument("--recompute_rms_norm", action="store_true")
+    parser.add_argument("--recompute_qkv_proj", action="store_true")
+    parser.add_argument("--recompute_attn", action="store_true")
+    parser.add_argument("--recompute_mlp", action="store_true")
+    parser.add_argument("--recompute_silu", action="store_true")
+    args = parser.parse_args()
+    print(args)
+
+    torch._functorch.config.activation_memory_budget = args.activation_memory_budget
+
+    if args.deterministic:
+        os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8"
+        os.environ["FLASH_ATTENTION_DETERMINISTIC"] = "1"
+        seed = 1729  # interesting
+        torch.manual_seed(seed)
+        torch.cuda.manual_seed(seed)
+        torch.cuda.manual_seed_all(seed)
+        torch.backends.cudnn.deterministic = True
+        torch.backends.cudnn.benchmark = False
+        torch.use_deterministic_algorithms(True)
+
+    if args.use_liger:
+        from liger_kernel.transformers import apply_liger_kernel_to_qwen2
+        apply_liger_kernel_to_qwen2()
+
+    # Init model
+    config = make_config()
+    layer = Qwen2DecoderLayer(config=config, layer_idx=0)
+    rotary_emb = Qwen2RotaryEmbedding(config, device="cuda")
+    layer.train().to(torch.bfloat16).cuda()
+
+    if args.compile:
+        layer.compile(dynamic=True)
+
+    # Make some dummy data
+    seqlen = args.seqlen
+    input_tensor = torch.randn(1, seqlen, config.hidden_size, dtype=torch.bfloat16, device="cuda")
+    position_ids = torch.arange(seqlen, dtype=torch.long, device="cuda")[None]
+    attention_mask = torch.ones_like(position_ids)
+
+    position_embeddings = rotary_emb(input_tensor, position_ids)
+    cu_seqlens = torch.tensor([0, seqlen], dtype=torch.int32, device="cuda")
+    max_seqlen = cu_seqlens.diff().max()
+
+    d_output_tensor = torch.randn_like(input_tensor)
+    input_tensor = input_tensor.detach().requires_grad_(True)
+
+    if args.type == "gargantua":
+        bench_qwen2_decoder_layer_gargantua(
+            layer=layer,
+            input_tensor=input_tensor,
+            position_embeddings=position_embeddings,
+            cu_seqlens=cu_seqlens,
+            max_seqlen=max_seqlen,
+            d_output_tensor=d_output_tensor,
+            recompute_rms_norm=args.recompute_rms_norm,
+            recompute_qkv_proj=args.recompute_qkv_proj,
+            recompute_attn=args.recompute_attn,
+            recompute_mlp=args.recompute_mlp,
+            recompute_silu=args.recompute_silu,
+        )
+
+    else:
+        bench_qwen2_decoder_layer_hf(
+            layer=layer,
+            input_tensor=input_tensor,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            position_embeddings=position_embeddings,
+            cu_seqlens=cu_seqlens,
+            max_seqlen=max_seqlen,
+            d_output_tensor=d_output_tensor,
+            recompute=args.recompute_hf,
+            recompute_skip_attn=args.recompute_hf_skip_attn,
+        )
+
+
+if __name__ == "__main__":
+    main()

playground/Abbie-h100/tests/bench_transformer_layer.py

@@ -0,0 +1,383 @@
+import argparse
+import os
+from contextlib import nullcontext
+
+import torch
+import torch.distributed as dist
+from transformers.models.qwen3_moe.modeling_qwen3_moe import Qwen3MoeRotaryEmbedding
+
+from abbie.device_mesh_manager import DMM
+from abbie.gargantua.config import GenericTransformerConfig
+from abbie.gargantua.functional import GargantuaLayerFunc
+from abbie.gargantua.layer import GenericTransformerLayer
+from abbie.gargantua.overlapper import get_overlapper
+from abbie.utils.deterministic_utils import set_deterministic
+from abbie.utils.flash_attn_utils import gather_cu_seqlens_from_position_ids
+
+
+MODEL_TYPE_TO_CONFIG_KWARGS = {
+    "qwen2_7b": {
+        "hidden_size": 3584,
+        "num_attention_heads": 28,
+        "num_key_value_heads": 4,
+        "use_qkv_bias": False,
+        "use_o_bias": False,
+        "use_qk_norm": False,
+        "intermediate_size": 18944,
+        "use_mlp_gate_up_bias": False,
+        "use_mlp_down_bias": False,
+    },
+    "qwen3_4b": {
+        "hidden_size": 2560,
+        "head_size": 128,
+        "num_attention_heads": 32,
+        "num_key_value_heads": 8,
+        "use_qkv_bias": False,
+        "use_o_bias": False,
+        "use_qk_norm": True,
+        "intermediate_size": 9728,
+        "use_mlp_gate_up_bias": False,
+        "use_mlp_down_bias": False,
+    },
+    "qwen3_8b": {
+        "hidden_size": 4096,
+        "head_size": 128,
+        "num_attention_heads": 32,
+        "num_key_value_heads": 8,
+        "use_qkv_bias": False,
+        "use_o_bias": False,
+        "use_qk_norm": True,
+        "intermediate_size": 12288,
+        "use_mlp_gate_up_bias": False,
+        "use_mlp_down_bias": False,
+    },
+    "qwen3_moe_30b": {
+        "hidden_size": 2048,
+        "head_size": 128,
+        "num_attention_heads": 32,
+        "num_key_value_heads": 4,
+        "use_qkv_bias": False,
+        "use_o_bias": False,
+        "use_qk_norm": True,
+        "num_experts_per_tok": 8,
+        "num_routed_experts": 128,
+        "moe_intermediate_size": 768,
+    },
+    "qwen3_moe_235b": {
+        "hidden_size": 4096,
+        "head_size": 128,
+        "num_attention_heads": 64,
+        "num_key_value_heads": 4,
+        "use_qkv_bias": False,
+        "use_o_bias": False,
+        "use_qk_norm": True,
+        "num_experts_per_tok": 8,
+        "num_routed_experts": 128,
+        "moe_intermediate_size": 1536,
+    },
+    # We don't have sink attention or expert bias yet
+    "gpt_oss_20b": {
+        "hidden_size": 2880,
+        "head_size": 64,
+        "num_attention_heads": 64,
+        "num_key_value_heads": 8,
+        "use_qkv_bias": False,
+        "use_o_bias": False,
+        "use_qk_norm": False,
+        "num_experts_per_tok": 4,
+        "num_routed_experts": 32,
+        "moe_intermediate_size": 2880,
+    },
+    # We don't have sink attention or expert bias yet
+    "gpt_oss_120b": {
+        "hidden_size": 2880,
+        "head_size": 64,
+        "num_attention_heads": 64,
+        "num_key_value_heads": 8,
+        "use_qkv_bias": False,
+        "use_o_bias": False,
+        "use_qk_norm": False,
+        "num_experts_per_tok": 4,
+        "num_routed_experts": 128,
+        "moe_intermediate_size": 2880,
+    },
+    # We don't have MLA or shared experts yet
+    "deepseek_v3": {
+        "hidden_size": 7168,
+        "head_size": 128,
+        "num_attention_heads": 128,
+        "num_key_value_heads": 128,
+        "use_qkv_bias": False,
+        "use_o_bias": False,
+        "use_qk_norm": True,
+        "num_experts_per_tok": 9,
+        "num_routed_experts": 256,
+        "moe_intermediate_size": 2048,
+    },
+}
+
+
+def get_gg_config(model_type: str, **extra_kwargs) -> GenericTransformerConfig:
+    kwargs = dict(MODEL_TYPE_TO_CONFIG_KWARGS[model_type])
+    kwargs.update(extra_kwargs)
+
+    return GenericTransformerConfig(
+        dp_group=DMM.dp_group,
+        pp_group=DMM.pp_group,
+        ep_group=DMM.ep_group,
+        norm_topk_prob=True,
+        use_moe_gate_up_bias=False,
+        use_moe_down_bias=False,
+        dtype=torch.bfloat16,
+        rope_theta=1e6,
+        rope_scaling={"type": "default"},
+        aux_loss_coef=None,
+        z_loss_coef=None,
+        **kwargs,
+    )
+
+
+def make_gg_layer(config: GenericTransformerConfig):
+    layer = GenericTransformerLayer(config, layer_idx=0)
+    layer.train().cuda()
+
+    for param in layer.parameters():
+        param.data.normal_(0, std=1e-3)
+
+    return layer
+
+
+def bench_transformer_layer(
+    model_type: str,
+    seqlen: int = 4096,
+    num_mini_batch: int = 4,
+    num_steps: int = 10,
+    token_dispatch_method: str = "all-to-all",
+    **extra_kwargs,
+):
+    # Init layer
+    config = get_gg_config(
+        model_type=model_type,
+        token_dispatch_method=token_dispatch_method,
+        **extra_kwargs,
+    )
+    layer = make_gg_layer(config)
+    rotary_emb = Qwen3MoeRotaryEmbedding(config, device="cuda")
+
+    if token_dispatch_method == "deep-ep":
+        from abbie.ops.deep_ep import setup_deep_ep_buffer
+
+        setup_deep_ep_buffer(
+            group=DMM.ep_group,
+            hidden_bytes=config.hidden_size * 2,
+            num_sms=20,
+        )
+
+    elif token_dispatch_method == "hybrid-ep":
+        from abbie.ops.hybrid_ep import setup_hybrid_ep_buffer
+
+        setup_hybrid_ep_buffer(
+            ep_group=DMM.ep_group,
+            hidden_dim=config.hidden_size,
+            max_num_of_tokens_per_rank=seqlen,
+            num_local_experts=config.num_routed_experts_per_rank,
+        )
+
+    if dist.get_rank() == 0:
+        print(config)
+
+    # Initialize some dummy inputs
+    input_tensor = torch.randn(seqlen, config.hidden_size, dtype=torch.bfloat16).cuda()
+    position_ids = []
+    while len(position_ids) < seqlen:
+        position_ids.extend(range(4096))
+    position_ids = position_ids[:seqlen]
+    position_ids = torch.tensor(position_ids, dtype=torch.long, device="cuda")
+
+    # attention_mask = torch.ones_like(position_ids)
+
+    position_embeddings = rotary_emb(input_tensor[None], position_ids[None])
+    cos, sin = position_embeddings[0][0], position_embeddings[1][0]
+    cu_seqlens, max_seqlen = gather_cu_seqlens_from_position_ids(position_ids)
+
+    d_output_tensor = torch.randn_like(input_tensor)
+    input_tensor.requires_grad_(True)
+
+    # Get the overlapper
+    overlapper = get_overlapper()
+
+    # Calculate some stats for perf calculations
+    ctx_size = None
+
+    n_local_params = 0
+    for param in layer.parameters():
+        n_local_params += param.numel()
+
+    n_attn_params = (config.num_attention_heads + config.num_key_value_heads) * 2
+    n_attn_params *= config.hidden_size * config.head_size
+
+    if config.num_experts_per_tok > 0:
+        n_expert_params = config.num_experts_per_tok * config.hidden_size * config.moe_intermediate_size * 3
+        n_act_params = n_attn_params + n_expert_params
+    else:
+        n_dense_params = config.hidden_size * config.intermediate_size * 3
+        n_act_params = n_attn_params + n_dense_params
+
+    seqlens = cu_seqlens.diff()
+    attn_tflop = (seqlens ** 2).sum().item() * config.hidden_size * 4 / 1e12
+
+    fwd_tflop = n_act_params * seqlen * 2 / 1e12
+    fwd_tflop += attn_tflop
+
+    event0 = torch.cuda.Event(enable_timing=True)
+    event1 = torch.cuda.Event(enable_timing=True)
+    event2 = torch.cuda.Event(enable_timing=True)
+    event3 = torch.cuda.Event(enable_timing=True)
+
+    if dist.get_rank() == 0:
+        print(f"n_local_params={n_local_params} n_act_params={n_act_params} {fwd_tflop=}")
+
+    for step_nb in range(num_steps):
+        total_forward_time = 0
+        total_overlap_time = 0
+        total_backward_time = 0
+
+        if step_nb == num_steps - 1:
+            profiler = torch.profiler.profile(
+                activities=[
+                    torch.profiler.ProfilerActivity.CPU,
+                    torch.profiler.ProfilerActivity.CUDA,
+                ]
+            )
+        else:
+            profiler = nullcontext()
+
+        with profiler:
+            for _ in range(num_mini_batch):
+                torch.cuda.synchronize()
+                dist.barrier()
+                event0.record()
+
+                ctx0, output_tensor0 = GargantuaLayerFunc.apply_module(
+                    layer=layer,
+                    x=input_tensor,
+                    cos=cos,
+                    sin=sin,
+                    cu_seqlens=cu_seqlens,
+                    max_seqlen=max_seqlen,
+                    global_num_tokens=seqlen,
+                )
+                event1.record()
+
+                if ctx_size is None:
+                    # This will only impact first step
+                    ctx_size = ctx0.calc_tensors_size()
+                    # n_tokens_per_expert_in_group = ctx0.meta.get("n_tokens_per_expert_in_group")
+
+                overlapper.on()
+                ctx1, output_tensor1 = GargantuaLayerFunc.apply_module(
+                    layer=layer,
+                    x=input_tensor,
+                    cos=position_embeddings[0],
+                    sin=position_embeddings[1],
+                    cu_seqlens=cu_seqlens,
+                    max_seqlen=max_seqlen,
+                    global_num_tokens=seqlen,
+                )
+                torch.autograd.backward(output_tensor0, d_output_tensor)
+                overlapper.off()
+                event2.record()
+
+                torch.autograd.backward(output_tensor1, d_output_tensor)
+                event3.record()
+
+                torch.cuda.synchronize()
+
+                total_forward_time += event0.elapsed_time(event1) / 1000.0
+                total_overlap_time += event1.elapsed_time(event2) / 1000.0
+                total_backward_time += event2.elapsed_time(event3) / 1000.0
+
+            if dist.get_rank() == 0:
+                fwd_tflops = fwd_tflop * num_mini_batch / total_forward_time
+                fwd_mfu = fwd_tflops / 989.5
+                bwd_tflops = fwd_tflop * num_mini_batch * 2 / total_backward_time
+                bwd_mfu = bwd_tflops / 989.5
+                overlap_tflops = fwd_tflop * num_mini_batch * 3 / total_overlap_time
+                overlap_mfu = overlap_tflops / 989.5
+
+                tokens_per_sec = seqlen * num_mini_batch / total_overlap_time
+                print(f"# {step_nb=}")
+                print("fwd / bwd / overlap")
+                print(f"time:\t{total_forward_time:.3f}\t{total_backward_time:.3f}\t{total_overlap_time:.3f}")
+                print(f"mfu:\t{fwd_mfu:.3f}\t{bwd_mfu:.3f}\t{overlap_mfu:.3f}")
+                print(f"tps: {tokens_per_sec:.1f}")
+                print(f"ctx_size={ctx_size / 1e9:.5f}GB")
+
+    if dist.get_rank() == 0:
+        if not isinstance(profiler, nullcontext):
+            profiler.export_chrome_trace("trace.json")
+
+    # print(f"rank={dist.get_rank()} ctx_size={ctx_size / 1e9:.5f}GB")
+    # import torch.distributed as DIST
+    # if DIST.get_rank() == 0:
+    #     import pdb; pdb.set_trace()
+    # DIST.barrier()
+
+
+def main():
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument("--model_type", default="qwen3_moe_30b", choices=MODEL_TYPE_TO_CONFIG_KWARGS.keys())
+
+    parser.add_argument("--seqlen", type=int, default=4096)
+    parser.add_argument("--ep", type=int, default=1)
+
+    parser.add_argument("--num_mini_batch", type=int, default=4)
+    parser.add_argument("--num_steps", type=int, default=10)
+
+    parser.add_argument("--recompute_norm", action="store_true")
+    parser.add_argument("--recompute_attn_up_proj", action="store_true")
+    parser.add_argument("--recompute_attn", action="store_true")
+    parser.add_argument("--recompute_attn_down_proj", action="store_true")
+    parser.add_argument("--recompute_mlp", action="store_true")
+    parser.add_argument("--recompute_mlp_act", action="store_true")
+    parser.add_argument("--recompute_dispatch", action="store_true")
+
+    parser.add_argument("--token-dispatch-method", type=str, default="all-to-all")
+
+    args = parser.parse_args()
+
+    rank = int(os.getenv("RANK"))
+    local_rank = int(os.getenv("LOCAL_RANK"))
+    world_size = int(os.getenv("WORLD_SIZE"))
+
+    device = f"cuda:{local_rank}"
+    torch.cuda.set_device(device)
+    dist.init_process_group(
+        backend="nccl", init_method="env://", world_size=world_size, rank=rank, device_id=torch.device(device)
+    )
+
+    set_deterministic()
+
+    try:
+        DMM.initialize(ep_size=args.ep)
+        bench_transformer_layer(
+            model_type=args.model_type,
+            seqlen=args.seqlen,
+            num_mini_batch=args.num_mini_batch,
+            num_steps=args.num_steps,
+            recompute_norm=args.recompute_norm,
+            recompute_attn_up_proj=args.recompute_attn_up_proj,
+            recompute_attn=args.recompute_attn,
+            recompute_attn_down_proj=args.recompute_attn_down_proj,
+            recompute_mlp=args.recompute_mlp,
+            recompute_mlp_act=args.recompute_mlp_act,
+            recompute_dispatch=args.recompute_dispatch,
+            token_dispatch_method=args.token_dispatch_method,
+        )
+    finally:
+        dist.destroy_process_group()
+
+
+if __name__ == "__main__":
+    main()

playground/Abbie-h100/tests/close_check.py

@@ -0,0 +1,45 @@
+import torch
+
+def allclose(x, y, pct=5.0):
+    mask = torch.isclose(x, y, rtol=1e-5)
+    pct_diff = (mask.numel() - mask.sum()) / mask.numel() * 100
+    if pct_diff > pct:
+        print(x[torch.logical_not(mask)], y[torch.logical_not(mask)])
+        print("Problem: {:.2f}% of values not close.".format(pct_diff))
+        return False
+    else:
+        print("Passed: {:.2f}% of, values not close pct.".format(pct_diff))
+        return True
+
+n_probs = torch.load( '/opt/tiger/n_probs.pt', weights_only=True)
+n_hidden_states_grad = torch.load('/opt/tiger/n_hidden_states_grad.pt', weights_only=True)
+n_rms_grad = torch.load('/opt/tiger/n_rms_grad.pt', weights_only=True)
+n_dense_grad = torch.load('/opt/tiger/n_dense_grad.pt', weights_only=True)
+n_query_layer_grad = torch.load('/opt/tiger/n_query_layer_grad.pt', weights_only=True)
+n_key_layer_grad = torch.load('/opt/tiger/n_key_layer_grad.pt', weights_only=True)
+n_value_layer_grad = torch.load('/opt/tiger/n_value_layer_grad.pt', weights_only=True)
+
+
+o_hidden_states_grad = torch.load('/opt/tiger/hidden_states_grad.pt', weights_only=True)
+o_hidden_states_grad = o_hidden_states_grad.squeeze()
+o_rms_grad = torch.load('/opt/tiger/o_rms_grad.pt', weights_only=True)
+o_dense_grad = torch.load('/opt/tiger/o_dense_grad.pt', weights_only=True)
+o_query_layer_grad = torch.load('/opt/tiger/o_query_layer_grad.pt', weights_only=True)
+o_key_layer_grad = torch.load('/opt/tiger/o_key_layer_grad.pt', weights_only=True)
+o_value_layer_grad = torch.load('/opt/tiger/o_value_layer_grad.pt', weights_only=True)
+
+query_diff = torch.max(torch.abs(o_query_layer_grad - n_query_layer_grad)).item()
+key_diff = torch.max(torch.abs(o_key_layer_grad - n_key_layer_grad)).item()
+value_diff = torch.max(torch.abs(o_value_layer_grad - n_value_layer_grad)).item()
+
+allclose(n_hidden_states_grad, o_hidden_states_grad)
+allclose(n_rms_grad.squeeze(), o_rms_grad.squeeze())
+allclose(n_dense_grad.squeeze(), o_dense_grad.squeeze())
+
+threshold = 1e-5
+if (query_diff < threshold and 
+    key_diff < threshold and 
+    value_diff < threshold):
+    print("\nPass!")
+else:
+    print(f"\nFailed! {query_diff} {key_diff} {value_diff}")

playground/Abbie-h100/tests/pipe_compare.py

@@ -0,0 +1,306 @@
+import math
+import os
+from typing import List, Tuple, Any, Optional
+
+import torch
+import torch.distributed as dist
+import time
+
+from torch.distributed.optim import ZeroRedundancyOptimizer
+
+from dualpipe.module.config import GargantuaConfig
+from dualpipe.module.gargantua.transformer_layer import TransformerGargantuaLayer
+from dualpipe.module.baseline.transformer_layer import TransformerLayer
+from dualpipe.module.parallel_states import build_rank_generator
+from dualpipe.module.shared.vocab import vocab_parallel_cross_entropy, initialize_kernel
+from dualpipe.communicator import Communicator
+from dualpipe import DualPipeTrainMoeV
+from dualpipe.module.debug import setup_dumper, enable_dumper, setup_sniffer
+
+_DEFAULT_LOCAL_DIR = '/opt/tiger/DualPipe/profiles'
+
+INITIALIZE_RANGE = 0.013975424859373685
+
+def shift_labels(labels, cu_seqlens):
+    pad_idx_tensor = torch.tensor(1).long().to(device=cu_seqlens.device)        
+    # Preprocess labels first. 
+    shift_labels = torch.cat((labels[1:], labels.new_ones((1))*pad_idx_tensor))
+    shift_labels.requires_grad = False
+    lbl_seq_lens = (cu_seqlens[1:] - 1).long()
+    shift_labels[lbl_seq_lens] = pad_idx_tensor
+    shift_labels = shift_labels.unsqueeze(0).transpose(0, 1).contiguous()
+    return shift_labels
+
+
+def criterion(output: torch.Tensor, labels: torch.Tensor, input_ctx: Tuple[Any]) -> torch.Tensor:
+    cu_seqlens = input_ctx[0]
+    sl = shift_labels(labels, cu_seqlens)
+    return vocab_parallel_cross_entropy(output, sl).transpose(0, 1).contiguous().mean()
+
+def duplicate_four(tl: List[torch.Tensor]):
+    r = tl + tl + tl + tl
+    return r
+
+def set_weight(layer: TransformerGargantuaLayer, layer2: TransformerGargantuaLayer, 
+               rank: int, pp_rank: int, total_rank: int, layer_number: int,
+               vocab_size: int, hidden_size:int, inner_size: int, dtype: torch.dtype, device: str):
+    real_n_layer = layer_number
+    std = INITIALIZE_RANGE / math.sqrt(2 * real_n_layer)
+    # real_n_layer = self.config.n_layer - len(self.config.noop_transformer_layers)
+    # p.data.normal_(mean=0.0, std=self.config.initializer_range / math.sqrt(2 * real_n_layer))
+    
+    vocab_embedding = torch.nn.Linear(hidden_size, vocab_size, dtype=dtype, device=device)
+    logits_embedding = torch.nn.Linear(hidden_size, vocab_size, dtype=dtype, device=device)
+    qkv = torch.nn.Linear(hidden_size, hidden_size * 3, bias=False, dtype=dtype, device=device) 
+    dense = torch.nn.Linear(hidden_size, hidden_size, bias=False, dtype=dtype, device=device)
+    w1 = torch.nn.Linear(hidden_size, 2 * inner_size, bias=False, dtype=dtype, device=device)
+    w2 = torch.nn.Linear(inner_size, hidden_size, bias=False, dtype=dtype, device=device)
+
+    qkv_rmsnorm_weight = [torch.ones(hidden_size * 3, dtype=dtype, device=device)]
+    rmsnorm_weight = [torch.ones(hidden_size, dtype=dtype, device=device)]
+    qkv_weight: List[torch.Tensor] = [qkv.weight]
+    dense_weight: List[torch.Tensor] = [dense.weight]
+    w1_weight: List[torch.Tensor] = [w1.weight]
+    w2_weight: List[torch.Tensor] = [w2.weight]
+    #gate_weight: List[torch.Tensor] = [a.weight for a in gate]
+
+    vocab_embedding.weight.data.normal_(mean=0.0, std=std)
+    logits_embedding.weight.data.normal_(mean=0.0, std=std)
+    for i in range(layer_number):
+        qkv_weight[i].data.normal_(mean=0.0, std=std)
+        dense_weight[i].data.normal_(mean=0.0, std=std)
+        w1_weight[i].data.normal_(mean=0.0, std=std)
+        w2_weight[i].data.normal_(mean=0.0, std=std)
+        #gate_weight[i].data.normal_(mean=0.0, std=std)
+    layer.set_weight(vocab_embedding.weight, logits_embedding.weight, qkv_weight, qkv_rmsnorm_weight, dense_weight, w1_weight, w2_weight, [], rmsnorm_weight)
+    layer2.set_weight(vocab_embedding.weight, logits_embedding.weight, qkv_weight, qkv_rmsnorm_weight, dense_weight, w1_weight, w2_weight, [], rmsnorm_weight)
+
+def dump_weight(rank, layer0, layer1):
+    # considering only two global ranks, 0 and 1 and layer_number = 1
+    # when world_rank == 0:
+    #     layer0 == vocab + l0
+    #     layer1 == l3 + lm_head
+    # when world_rank == 1:
+    #     layer0 == l1 
+    #     layer1 == l2
+
+
+    p = "/opt/tiger/dump"
+    if rank == 0:
+        print("Saving for rank 0 ...")
+        torch.save(layer0.embedding.weight, f'{p}/vocab_embedding.pt')
+        torch.save(layer1.lm_head, f'{p}/lm_head.pt')
+        torch.save(layer0.qkv[0], f"{p}/qkv_l_0.pt",)
+        torch.save(layer1.qkv[0], f"{p}/qkv_l_3.pt")
+        torch.save(layer0.dense[0], f"{p}/dense_l_0.pt")
+        torch.save(layer1.dense[0], f"{p}/dense_l_3.pt")
+        torch.save(layer0.w1[0], f"{p}/w1_l_0.pt")
+        torch.save(layer1.w1[0], f"{p}/w1_l_3.pt",)
+        torch.save(layer0.w2[0], f"{p}/w2_l_0.pt",)
+        torch.save(layer1.w2[0], f"{p}/w2_l_3.pt")
+    elif rank == 1:
+        print("Saving for rank 1...")
+        torch.save(layer0.qkv[0], f"{p}/qkv_l_1.pt")
+        torch.save(layer1.qkv[0], f"{p}/qkv_l_2.pt")
+        torch.save(layer0.dense[0], f"{p}/dense_l_1.pt")
+        torch.save(layer1.dense[0], f"{p}/dense_l_2.pt")
+        torch.save(layer0.w1[0], f"{p}/w1_l_1.pt")
+        torch.save(layer1.w1[0], f"{p}/w1_l_2.pt")
+        torch.save(layer0.w2[0], f"{p}/w2_l_1.pt")
+        torch.save(layer1.w2[0], f"{p}/w2_l_2.pt")
+
+def load_weight(layer):
+    p = "/opt/tiger/dump"
+    layer.embedding.weight.data.copy_(torch.load(f'{p}/vocab_embedding.pt'))
+    layer.lm_head.data.copy_(torch.load(f'{p}/lm_head.pt'))
+    for i in range(4):
+        layer.qkv[i].data.copy_(torch.load(f'{p}/qkv_l_{i}.pt'))
+        layer.dense[i].data.copy_(torch.load(f'{p}/dense_l_{i}.pt'))
+        layer.w1[i].data.copy_(torch.load(f'{p}/w1_l_{i}.pt'))
+        layer.w2[i].data.copy_(torch.load(f'{p}/w2_l_{i}.pt'))
+
+def all_same(a, b):
+    assert not (a - b).nonzero().any()
+
+def compare_weight(rank, l, m0, m1):
+    if rank == 0:
+        all_same(l.embedding.weight, m0.embedding.weight)
+        all_same(l.lm_head, m1.lm_head)
+        all_same(l.qkv[0], m0.qkv[0])
+        all_same(l.qkv[3], m1.qkv[0])
+        all_same(l.dense[0], m0.dense[0])
+        all_same(l.dense[3], m1.dense[0])
+        all_same(l.w1[0], m0.w1[0])
+        all_same(l.w1[3], m1.w1[0])
+        all_same(l.w2[0], m0.w2[0])
+        all_same(l.w2[3], m1.w2[0])
+        print("verified on rank 0")
+    else:
+        all_same(l.qkv[1], m0.qkv[0])
+        all_same(l.qkv[2], m1.qkv[0])
+        all_same(l.dense[1], m0.dense[0])
+        all_same(l.dense[2], m1.dense[0])
+        all_same(l.w1[1], m0.w1[0])
+        all_same(l.w1[2], m1.w1[0])
+        all_same(l.w2[1], m0.w2[0])
+        all_same(l.w2[2], m1.w2[0])
+        print("verified on rank 1")
+    
+
+def build_inputs_and_labels(rank, micro_batch_size, num_chunk, hidden_size: int, offset: int=1, mod_num:int=16):
+    inputs = []
+    cu_seqlens = []
+    total_s = []
+    labels = []
+    input_shapes = []
+    for x in range(num_chunk):
+        i = (x) % mod_num
+        i0 = torch.load(f'/opt/tiger/DualPipe/sample_data/moe_dump_ids_labels_only/input_ids_rank_{i}.pt', weights_only=True).to(device=f'cuda:{rank}')
+        c0 = torch.load(f'/opt/tiger/DualPipe/sample_data/moe_dump_ids_labels_only/cu_seqlens_rank_{i}.pt', weights_only=True).to(device=f'cuda:{rank}')
+        l0 = torch.load(f'/opt/tiger/DualPipe/sample_data/moe_dump_ids_labels_only/labels_{i}.pt', weights_only=True).to(device=f'cuda:{rank}')
+        t0 = c0[-1].item()
+        s0 = (t0, micro_batch_size, hidden_size)
+        inputs.append(i0)
+        cu_seqlens.append(c0)
+        total_s.append(t0)
+        labels.append(l0)
+        input_shapes.append(s0)
+    return inputs, cu_seqlens, total_s, labels, input_shapes
+
+
+def main(rank, ngpus, pp_size: int = 2,
+         vocab_size: int = 136064,
+         hidden_size: int = 4096,
+         inner_size: int = 5504,
+         num_attention_head: int = 32,
+         micro_batch_size: int=1,
+         num_chunks: int=20,
+         layer_number: int=1):
+    setup_dumper(rank, 1)    
+    #enable_dumper()
+    torch.cuda.set_device(rank)
+    torch.manual_seed(42)
+    dist.init_process_group(backend='nccl', init_method="env://", world_size=ngpus, rank=rank)
+    torch.set_default_device(f"cuda:{rank}")
+    #initialize_kernel()
+    os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8"
+    group = dist.distributed_c10d._get_default_group()
+    world_size = group.size()
+    rank_generator = build_rank_generator(rank, world_size, 1, 1, pp_size)
+    rank_generator.init()
+    pp_group = rank_generator.get_pp_group()
+    pp_rank = torch.distributed.get_rank(pp_group)
+
+    gargantua_config = (
+        GargantuaConfig(
+            vocab_size, hidden_size, -1, num_attention_head, hidden_size, is_moe=False)
+                .with_dense_inner_size(inner_size)
+                .with_async_comm()
+                )
+
+    # init a communicator
+    comm = Communicator(rank, pp_group)
+    comm.setup_shape([(1, micro_batch_size, hidden_size)], torch.bfloat16)
+
+    first_rank = rank_generator.is_first_rank()
+    m0 = TransformerGargantuaLayer(rank_generator, gargantua_config, layer_number=layer_number, first_stage=first_rank)
+    m1 = TransformerGargantuaLayer(rank_generator, gargantua_config, layer_number=layer_number, last_stage=first_rank)    
+    set_weight(m0, m1, rank, pp_rank, ngpus, layer_number, vocab_size, hidden_size, inner_size, torch.bfloat16, f'cuda:{rank}')
+    dump_weight(rank, m0, m1)
+    #if rank == 0:
+    #    baseline = TransformerGargantuaLayer(rank_generator, gargantua_config, layer_number=layer_number * 4, first_stage=True, last_stage=True)
+    #    load_weight(baseline)
+    #    compare_weight(rank, baseline, m0, m1)
+    #else:
+    #    baseline = None
+    local_modules = torch.nn.Sequential(m0, m1)
+    #ddp_module = DDP(ddp_config, local_modules, rank_generator.get_dp_group())
+
+    # ddp_module = DDP(local_modules)
+    dualpipev_model = DualPipeTrainMoeV(local_modules, comm, rank_mapping=rank_generator.get_pp_ranks(), batch_dim=1, enable_overlap_fwd_bwd=True)
+    
+    dense_optim = ZeroRedundancyOptimizer(
+        m0.dense_parameters() + m1.dense_parameters(),
+        optimizer_class=torch.optim.AdamW,
+        lr=3e-5,
+        process_group=rank_generator.get_dp_group(),
+    )
+    if rank_generator.is_first_rank():
+        print(f"[Rank-{rank}] I am the first rank among {ngpus=}, {inner_size}, {hidden_size=}, {num_attention_head=}", flush=True)
+        print(f"[Rank]")
+    hidden_states, cu_seqlens, total_s, l, hidden_shapes = build_inputs_and_labels(rank, micro_batch_size, num_chunks, hidden_size, offset=rank)
+
+    dense_optim.zero_grad()
+    if not rank_generator.is_first_rank():
+        hidden_states = [None for _ in range(num_chunks)]
+    input_ctx = [(c, t) for c, t in zip(cu_seqlens, total_s)]
+    loss, outputs = dualpipev_model.step(hidden_states, input_shapes=hidden_shapes, input_ctx=input_ctx, num_chunks=num_chunks, criterion=criterion, labels=l, return_outputs=False)
+
+    if loss is not None:
+        print(f"[Rank-{rank}]: loss mean = {loss.mean()}")                
+    dense_optim.step()
+
+    print(f"[{rank}] {loss}")
+
+def main_two(rank, ngpus, pp_size: int = 2,
+         vocab_size: int = 136064,
+         hidden_size: int = 4096,
+         inner_size: int = 5504,
+         num_attention_head: int = 32,
+         micro_batch_size: int=1,
+         num_chunks: int=20,
+         layer_number: int=1):
+    setup_sniffer(rank, 1)
+    setup_dumper(rank, 1)
+    torch.cuda.set_device(rank)
+    torch.manual_seed(42)
+    dist.init_process_group(backend='nccl', init_method="env://", world_size=ngpus, rank=rank)
+    torch.set_default_device(f"cuda:{rank}")
+    #initialize_kernel()
+    os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8"
+    group = dist.distributed_c10d._get_default_group()
+    world_size = group.size()
+    rank_generator = build_rank_generator(rank, world_size, 1, 1, 1)
+    rank_generator.init()
+
+    gargantua_config = (
+        GargantuaConfig(
+            vocab_size, hidden_size, -1, num_attention_head, hidden_size, is_moe=False)
+                .with_dense_inner_size(inner_size)
+                .with_async_comm()
+                )
+
+    # init a communicator
+    first_rank = rank_generator.is_first_rank()
+    if rank == 0:
+        baseline = TransformerGargantuaLayer(rank_generator, gargantua_config, layer_number=layer_number * 4, first_stage=True, last_stage=True)
+        load_weight(baseline)
+
+        hidden_states, cu_seqlens, total_s, l, hidden_shapes = build_inputs_and_labels(rank, micro_batch_size, num_chunks, hidden_size, offset=rank)
+        for i in range(len(hidden_states)):
+            if hidden_states[i].shape[1] != 8187:
+                print(f"skipping shape: {hidden_states[i].shape}")
+                continue
+            input_id = hidden_states[i].clone()
+            cu_seqlen = cu_seqlens[i].clone()
+            label = l[i].clone()
+            total_s = cu_seqlen[-1].item()
+            sl = shift_labels(label, cu_seqlen)
+            baseline.set_input_ctx((cu_seqlen, total_s))
+            res = baseline.forward(input_id)
+            baseline_loss = vocab_parallel_cross_entropy(res, sl)
+            baseline_loss = baseline_loss.transpose(0, 1).contiguous().mean()
+            print(f"[Rank-{rank}] Loss_mean: {baseline_loss}")
+            baseline_loss.backward()
+        print("Finish baseline")
+
+def test_cross_node(ngpus):
+    #torch.multiprocessing.spawn(main, args=(ngpus,), nprocs=ngpus, daemon=True)
+    torch.multiprocessing.spawn(main_two, args=(ngpus,), nprocs=ngpus, daemon=True)
+
+
+if __name__ == "__main__":
+    num_gpus = torch.cuda.device_count()
+    testing_gpu = 2
+    assert testing_gpu <= num_gpus
+    test_cross_node(testing_gpu)

playground/Abbie-h100/tests/shard_parquet.py

@@ -0,0 +1,62 @@
+import pandas as pd
+import os
+from pathlib import Path
+
+
+def shard_parquet(input_path: str, output_dir: str, num_shards: int = 8):
+    """
+    Shard a parquet file into multiple smaller files.
+    
+    Args:
+        input_path: Path to input parquet file
+        output_dir: Directory to save sharded files
+        num_shards: Number of shards to create (default: 8)
+    
+    Returns:
+        List of output file paths
+    """
+    # Create output directory
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Read entire file
+    df = pd.read_parquet(input_path)
+    total_rows = len(df)
+    
+    # Calculate rows per shard
+    rows_per_shard = total_rows // num_shards
+    remainder = total_rows % num_shards
+    
+    # Create output file paths
+    input_name = Path(input_path).stem
+    output_paths = []
+    
+    current_idx = 0
+    
+    for i in range(num_shards):
+        # Calculate shard size (distribute remainder across first few shards)
+        shard_size = rows_per_shard + (1 if i < remainder else 0)
+        
+        # Extract shard data
+        start_idx = current_idx
+        end_idx = current_idx + shard_size
+        shard_df = df.iloc[start_idx:end_idx].copy()
+        
+        # Create output path
+        output_path = os.path.join(output_dir, f"{input_name}_shard_{i:03d}.parquet")
+        output_paths.append(output_path)
+        
+        # Save shard
+        shard_df.to_parquet(output_path, compression='snappy', index=False)
+        
+        print(f"Shard {i}: {len(shard_df):,} rows -> {output_path}")
+        
+        current_idx = end_idx
+    
+    print(f"Total: {total_rows:,} rows split into {num_shards} shards")
+    return output_paths
+
+
+# Example usage
+if __name__ == '__main__':
+    # Shard a parquet file into 8 sub-files
+    output_files = shard_parquet("/opt/tiger/datasets/train-00000-of-00001-b513d9e388d56453.parquet", "/opt/tiger/datasets/", num_shards=8)

playground/Abbie-h100/tests/shared/download.sh

@@ -0,0 +1,23 @@
+mkdir -p /opt/tiger/tokenizer
+mkdir -p /opt/tiger/model_weights
+mkdir -p /opt/tiger/datasets
+
+# For model weights dump
+cd /opt/tiger/model_weights
+hdfs dfs get hdfs://harunava/home/byte_tteng_llm/user/yuyifeng.oscar/moe_ep2 
+hdfs dfs get hdfs://harunava/home/byte_tteng_llm/user/yuyifeng.oscar/1b2
+# with GQA version.
+hdfs dfs get hdfs://harunava/home/byte_tteng_llm/users/yuyifeng.oscar/dense_gqa2_4ranks
+
+# For inputs sample
+cd /opt/tiger/datasets
+hdfs dfs get hdfs://harunava/home/byte_tteng_llm/user/yuyifeng.oscar/moe_ep2_inputs inputs_58M_2ranks
+hdfs dfs get hdfs://harunava/home/byte_tteng_llm/user/yuyifeng.oscar/inputs_58M_4ranks
+hdfs dfs get hdfs://harunava/home/byte_tteng_llm/user/yuyifeng.oscar/inputs_58M
+
+# For tokenizer 
+cd /opt/tiger/tokenizer
+hdfs dfs get hdfs://harunava/home/byte_tteng_llm/user/thoth/tokenizer/bbpe-136k-ml-1227
+
+# 
+cd /opt/tiger/Abbie

playground/Abbie-h100/tests/shared/moe_route.py

@@ -0,0 +1,115 @@
+import os
+
+import torch
+
+from dualpipe.module.config import GargantuaConfig
+from dualpipe.module.debug import MEM
+from dualpipe.module.gargantua.aux_loss import AuxLoadbalancingLoss
+from dualpipe.module.gargantua.functors import LinearMegatronFunc, LinearTEFunc, TopkFunc, TopKSoftmaxFunc
+
+
+use_te_router_linear = os.getenv("ENABLE_GARGANTUA_TE_ROUTER_LINEAR", "1") == "1"
+
+
+def z_loss_func(logits, z_loss_coeff):
+    """Encourages the router's logits to remain small to enhance stability.
+    Please refer to the ST-MoE paper (https://arxiv.org/pdf/2202.08906.pdf) for details.
+
+    Args:
+        logits (torch.Tensor): The logits of the router.
+
+    Returns:
+        torch.Tensor: The logits after applying the z-loss.
+    """
+
+    z_loss = torch.mean(torch.square(torch.logsumexp(logits, dim=-1))) * z_loss_coeff
+    return z_loss
+
+
+class MoERouterFunc:
+    @staticmethod
+    def forward(hidden_states, gating: torch.Tensor, num_experts: int, config: GargantuaConfig, input_jitter=None):
+        topk = config.moe_router_topk
+        hidden_dtype = hidden_states.dtype
+        routing_type = config.moe_router_load_balancing_type
+        input_fp32 = hidden_states.float()
+        with torch.cuda.amp.autocast(dtype=torch.float32):
+            # jitter.
+            logits = torch.nn.functional.linear(input_fp32, gating.to(dtype=input_fp32.dtype))
+            if config.moe_z_loss_coeff is not None:
+                z_loss = z_loss_func(logits, config.moe_z_loss_coeff)
+            logits = logits.view(-1, num_experts)
+
+            if routing_type == "aux_loss":
+                probs_fp32, indices, tokens_per_expert, input_shape, topk_softmax_scores, topk, top_k_dim = (
+                    TopKSoftmaxFunc.forward(logits, num_experts, topk)
+                )
+
+                # Apply load balancing loss
+                scores = torch.softmax(logits, dim=-1, dtype=torch.float32)
+                MEM.add_test("top_k_score_softmaxed", scores)
+                probs_fp32, aux_loss = AuxLoadbalancingLoss.forward(scores, tokens_per_expert, probs_fp32, config)
+                MEM.add_test("aux_loss_probs", probs_fp32)
+        probs = probs_fp32.to(dtype=hidden_dtype)
+        return probs, probs_fp32, indices, aux_loss, input_fp32, gating, input_shape, top_k_dim, logits
+
+    @staticmethod
+    def backward(
+        grad_output,
+        probs,
+        probs_fp32,
+        aux_loss,
+        tokens_per_expert,
+        config: GargantuaConfig,
+        indices,
+        input_shape,
+        top_k_dim,
+        input_fp32,
+        gating,
+        logits,
+    ):
+        # TODO [yuyifeng.oscar] tricky tricky here to align grad_output to moe_baseline_router's backward probs(scores) grad.
+        # grad_output = grad_output.to(torch.bfloat16).to(torch.float32)
+        MEM.add_test_grad("router_grad_32", grad_output)
+        MEM.add_test("r_probs", probs)
+        # Calculate gradient from main loss path (dL/dprobs -> dL/dlogits_topk -> dL/dlogits)
+        # grad_topk = torch.ops.aten._softmax_backward_data(grad_output, probs.to(torch.float32), dim=top_k_dim, input_dtype=torch.float32)
+        g_probs_fp32 = grad_output.to(dtype=torch.float32)
+        grad_topk = torch.ops.aten._softmax_backward_data(
+            g_probs_fp32, probs_fp32, dim=top_k_dim, input_dtype=torch.float32
+        )
+        # grad_topk = SoftmaxFunc.backward(grad_output, probs, top_k_dim)#.to(dtype=torch.bfloat16)
+        MEM.add_test_grad("r_topk", grad_topk)
+        grad_logits_from_main_loss = TopkFunc.backward(grad_topk, indices, input_shape, top_k_dim)
+
+        # Calculate gradient from aux_loss path (dAuxLoss -> dAuxLoss/dScores_softmax -> dAuxLoss/dLogits)
+        # Recalculate scores_softmax as it's needed for aux loss backward
+        scores_softmax = torch.softmax(logits, dim=-1, dtype=torch.float32)
+        grad_scores_softmax_from_aux, _, _, _ = AuxLoadbalancingLoss.backward(
+            grad_logits_from_main_loss,
+            scores_softmax,
+            aux_loss,
+            tokens_per_expert,
+            config.moe_router_topk,
+            config.moe_aux_loss_coeff,
+        )
+
+        # Calculate dAuxLoss / dLogits using softmax backward
+        grad_logits_from_aux = torch.ops.aten._softmax_backward_data(
+            grad_scores_softmax_from_aux, scores_softmax, dim=-1, input_dtype=logits.dtype
+        )
+
+        # Combine gradients from both paths
+        grad_logits_total = grad_logits_from_main_loss + grad_logits_from_aux
+        # gating backward (dL/dLogits -> dL/dInput, dL/dGating)
+        gating = gating.to(dtype=grad_logits_total.dtype)
+        if use_te_router_linear:
+            grad_input = LinearTEFunc.backward(grad_logits_total, input_fp32, gating)
+            grad_input = grad_input.squeeze()
+        else:
+            grad_input = LinearMegatronFunc.backward(grad_logits_total, input_fp32, gating)
+        MEM.add_test_grad("r_gate_grad", grad_input)
+
+        # Return gradients for hidden_states (input) and gating weight
+
+        return grad_input, gating.grad, None, None, None

playground/Abbie-h100/tests/shared/optimizer.py

@@ -0,0 +1,103 @@
+from typing import Dict
+import torch
+import math
+from torch.distributed.optim import ZeroRedundancyOptimizer
+
+# -----------------------------  configurable hyper-params  -----------------------------
+total_steps = 50000  # how many optimiser.step() calls you expect
+warmup_steps = 200  # ≈ 1-3 % of total_steps is typical
+lr_max = 3e-4  # peak LR  (your “LRmax”)
+lr_min = 3e-5  # final LR (usually 0.05-0.1 × lr_max)
+hold_steps = 0  # optional: keep lr_min flat for the last N steps
+
+
+# ---------------------------------------------------------------------------------------
+
+def lr_lambda(current_step: int):
+    """
+    0-----warm-up----------cosine----------flat--> 1   (returns *multiplicative* factor)
+    """
+    if current_step < warmup_steps:  # linear warm-up
+        return float(current_step) / float(max(1, warmup_steps))
+
+    progress = (current_step - warmup_steps) / float(max(1, total_steps - warmup_steps - hold_steps))
+    progress = min(progress, 1.0)  # clip in case total_steps not precise
+
+    if current_step < total_steps - hold_steps:  # cosine decay
+        cosine = 0.5 * (1.0 + math.cos(math.pi * progress))
+        return cosine * (lr_max - lr_min) / lr_max + lr_min / lr_max
+
+    return lr_min / lr_max  # flat tail
+
+
+def get_lr_lambda(constant: bool):
+    if constant:
+        return lambda _: lr_max
+    else:
+        return lr_lambda
+
+
+def build_optimizer(rank, world_size, module, dp_group, zero_redundant=False):
+    master_params = []
+    param_to_master_param = {}
+    name_to_param_and_master_param = {}
+    for name, param in module.named_parameters():        
+        # Master gradient 
+        print(f"[Rank-{rank}] GRAD_ACC, param name: {name} size: {param.shape} require_grad: {param.requires_grad}")
+        #p = param.detach().clone().float().requires_grad_()
+        p = torch.empty_like(param, dtype=torch.float32)
+        # Allocation of parameter's so called "main_grad"
+        # In TE Linear core (functors) they are just accumulated directly.
+        param.main_grad = p 
+        master_params.append(p)
+        param_to_master_param[param] = p
+        name_to_param_and_master_param[name] = (param, p)
+
+    if world_size > 1 or zero_redundant:
+        optimizer = ZeroRedundancyOptimizer(
+            module.parameters(), # Still using old module's params.
+            optimizer_class=torch.optim.AdamW,
+            lr=lr_max,
+            weight_decay=0.1,
+            betas=(0.9, 0.95),
+            process_group=dp_group,
+        )
+    else:
+        optimizer = torch.optim.AdamW(master_params, lr=lr_max, betas=(0.9, 0.95), weight_decay=0.1)
+
+    # opt_param_scheduler = get_optimizer_param_scheduler(optimizer)
+    print(
+        f"Allocated CUDA Memory after configure optimizer: {torch.cuda.memory_allocated() / 1000.0 / 1000 / 1000} GB")
+    return optimizer, master_params, param_to_master_param, name_to_param_and_master_param
+
+# This shall be booked mainly for optimizer to work. 
+def copy_back_grads(name_to_param_and_master_param):
+    with torch.no_grad():
+        for name, (p_bf16, p32_as_grad) in name_to_param_and_master_param.items():
+            if p_bf16.grad is None:
+                p_bf16.grad = p32_as_grad.bfloat16().clone()
+            else:
+                p_bf16.grad.copy_(p32_as_grad.bfloat16())
+            #assert p_bf16.grad.type() == 'torch.cuda.HalfTensor'
+            #assert p_bf16.grad.type() == 'torch.cuda.BFloat16Tensor'
+
+def zero_out_master_grads(name_to_param_and_master_param):
+    print(f"Zeroing out accumulated master grad")
+    with torch.no_grad():
+        for name, (p_bf16, p32_grad) in name_to_param_and_master_param.items():
+            if p_bf16.grad is not None:
+                p_bf16.grad = None
+            p32_grad.zero_()
+
+def sample_check_pow2_grad(module):
+    grads = []
+    total_grad = 0.0
+    for n, param in module.named_parameters():
+        if param.main_grad is not None:
+            copied = param.main_grad.clone().detach()
+        else:
+            copied = param.grad.clone().detach()
+        total_grad += copied.pow(2).sum()
+        #assert param.grad.type() == 'torch.cuda.FloatTensor'
+        print(f"{n} param shape: {copied.shape} grad mean: {copied.mean()}  pow_2_sum: {copied.pow(2).sum()}")
+        grads.append(copied)

playground/Abbie-h100/tests/shared/preparation.py

@@ -0,0 +1,364 @@
+import math
+import torch
+from typing import Optional
+from dualpipe.module.parallel_states import RankGenerator
+
+NO_GQA_WEIGHT_PATH = '/opt/tiger/model_weights/1b2_4rank'
+GQA_WEIGHT_PATH = '/opt/tiger/model_weights/dense_gqa2_4ranks/rank0'
+MOE_WEIGHT_PATH = '/opt/tiger/model_weights/moe_weight'
+MOE_WEIGHT_EP_PATH = '/opt/tiger/model_weights/moe_ep2'
+TEST_PARQUET = "/opt/tiger/datasets/train-00000-of-00001-b513d9e388d56453.parquet"
+SAHARA_INPUT_58M_PATH = '/opt/tiger/datasets/inputs_58M'
+SAHARA_INPUT_58M_PATH_2RANK = '/opt/tiger/datasets/inputs_58M_2ranks'
+SAHARA_INPUT_426M_PATH_2RANK = '/opt/tiger/datasets/inputs_426M_2ranks'
+SAHARA_INPUT_58M_PATH_4RANK_MBS1 = '/opt/tiger/datasets/inputs_20250821_4rank'
+SAHARA_INPUT_58M_PATH_4RANK_MBS2 = '/opt/tiger/datasets/input_58M_4rank_mbs2'
+
+def get_parquet(rank, world_size):
+    if world_size == 1:
+        return TEST_PARQUET
+    else:
+        return f"hdfs://harunava/home/byte_tteng_llm/data/final_datasets/thoth_v2_15T_0612_sample_200B/459eaadf/train/part-0000{rank}-51b7c256-8c76-480f-8dcc-6cd0946003b1-c000.snappy.parquet"
+        # return f"{TEST_PARQUET_TEMPLATE}_shard_00{rank}.parquet"
+
+
+def preprare_data_input_58M(dp_rank, world_rank=None, mbs: int=1):
+    # for i in range(2):
+    if world_rank is None:
+        world_rank = dp_rank
+    input_ids = torch.load(f'{SAHARA_INPUT_58M_PATH}/input_ids_{dp_rank + 1}.pt', map_location=f'cuda:{world_rank}')
+    cu_seqlens = torch.load(f'{SAHARA_INPUT_58M_PATH}/cu_seqlens_{dp_rank + 1}.pt', map_location=f'cuda:{world_rank}')
+    word_idx = torch.load(f'{SAHARA_INPUT_58M_PATH}/word_idx_{dp_rank + 1}.pt', map_location=f'cuda:{world_rank}')
+    position_idx = torch.load(f'{SAHARA_INPUT_58M_PATH}/position_ids_{dp_rank + 1}.pt', map_location=f'cuda:{world_rank}')
+    lbl = torch.load(f'{SAHARA_INPUT_58M_PATH}/lbl_seq_lens_{dp_rank + 1}.pt', map_location=f'cuda:{world_rank}')
+    return input_ids, cu_seqlens, lbl, position_idx, word_idx
+
+def preprare_data_input_58M_4rank(dp_rank, world_rank=None, mbs = 1):
+    # for i in range(2):
+    if world_rank is None:
+        world_rank = dp_rank
+    if mbs == 1:
+        SAHARA_INPUT_58M_PATH_4RANK = SAHARA_INPUT_58M_PATH_4RANK_MBS1
+    elif mbs == 2:
+        SAHARA_INPUT_58M_PATH_4RANK = SAHARA_INPUT_58M_PATH_4RANK_MBS2
+    else:
+        raise Exception("No dump data available for mbs not in (1,2) and dp_size=4")
+    print(f"preparing 4 rank data from {SAHARA_INPUT_58M_PATH_4RANK}")    
+    input_ids = torch.load(f'{SAHARA_INPUT_58M_PATH_4RANK}/input_ids_rank{dp_rank}_1.pt', map_location=f'cuda:{world_rank}')
+    cu_seqlens = torch.load(f'{SAHARA_INPUT_58M_PATH_4RANK}/cu_seqlens_rank{dp_rank}_1.pt', map_location=f'cuda:{world_rank}')
+    word_idx = torch.load(f'{SAHARA_INPUT_58M_PATH_4RANK}/word_idx_rank{dp_rank}_1.pt', map_location=f'cuda:{world_rank}')
+    position_idx = torch.load(f'{SAHARA_INPUT_58M_PATH_4RANK}/position_ids_rank{dp_rank}_1.pt', map_location=f'cuda:{world_rank}')
+    lbl = torch.load(f'{SAHARA_INPUT_58M_PATH_4RANK}/lbl_seq_lens_rank{dp_rank}_1.pt', map_location=f'cuda:{world_rank}')
+    return input_ids, cu_seqlens, lbl, position_idx, word_idx
+
+def preprare_data_input_58M_2rank(dp_rank, world_rank=None, mbs: int=1):
+    # for i in range(2):
+    if world_rank is None:
+        world_rank = dp_rank
+    input_ids = torch.load(f'{SAHARA_INPUT_58M_PATH_2RANK}/input_ids_rank{dp_rank}_1.pt', map_location=f'cuda:{world_rank}')
+    cu_seqlens = torch.load(f'{SAHARA_INPUT_58M_PATH_2RANK}/cu_seqlens_rank{dp_rank}_1.pt', map_location=f'cuda:{world_rank}')
+    word_idx = torch.load(f'{SAHARA_INPUT_58M_PATH_2RANK}/word_idx_rank{dp_rank}_1.pt', map_location=f'cuda:{world_rank}')
+    position_idx = torch.load(f'{SAHARA_INPUT_58M_PATH_2RANK}/position_ids_rank{dp_rank}_1.pt', map_location=f'cuda:{world_rank}')
+    lbl = torch.load(f'{SAHARA_INPUT_58M_PATH_2RANK}/lbl_seq_lens_rank{dp_rank}_1.pt', map_location=f'cuda:{world_rank}')
+    return input_ids, cu_seqlens, lbl, position_idx, word_idx
+
+def prepare_data_input_426M_2rank(dp_rank, world_rank=None, mbs: int=1):
+    if world_rank is None:
+        world_rank = dp_rank
+    input_ids = []
+    cu_seqlens = []
+    word_idx = []
+    position_idx = []
+    lbl = []
+    for i in range(6):        
+        input_ids += torch.load(f'{SAHARA_INPUT_426M_PATH_2RANK}/input_ids_rank{dp_rank}_{i+1}.pt', map_location=f'cuda:{world_rank}')
+        cu_seqlens += torch.load(f'{SAHARA_INPUT_426M_PATH_2RANK}/cu_seqlens_rank{dp_rank}_{i+1}.pt', map_location=f'cuda:{world_rank}')
+        word_idx += torch.load(f'{SAHARA_INPUT_426M_PATH_2RANK}/word_idx_rank{dp_rank}_{i+1}.pt', map_location=f'cuda:{world_rank}')
+        position_idx += torch.load(f'{SAHARA_INPUT_426M_PATH_2RANK}/position_ids_rank{dp_rank}_{i+1}.pt', map_location=f'cuda:{world_rank}')
+        lbl += torch.load(f'{SAHARA_INPUT_426M_PATH_2RANK}/lbl_seq_lens_rank{dp_rank}_{i+1}.pt', map_location=f'cuda:{world_rank}')
+    return input_ids, cu_seqlens, lbl, position_idx, word_idx
+    
+
+def get_sahara_58M_dataloader(dp_rank, dp_size, seq_len, tokenizer, mbs: int = 1, world_rank=None):
+    assert seq_len == 4096, "currently for sahara dump it's dumped in 4K fashion for test purpose"
+    if dp_size == 1:
+        input_ids, cu_seqlens, lbl_seq_lens, position_idxs, word_idxs = preprare_data_input_58M(dp_rank, world_rank, mbs)
+    elif dp_size == 2:
+        print("Using 2 rank sahara dump")
+        input_ids, cu_seqlens, lbl_seq_lens, position_idxs, word_idxs = preprare_data_input_58M_2rank(dp_rank, world_rank, mbs)
+    elif dp_size == 4:
+        print("Using 4 rank sahara dump")
+        input_ids, cu_seqlens, lbl_seq_lens, position_idxs, word_idxs = preprare_data_input_58M_4rank(dp_rank, world_rank, mbs)
+    else:
+        raise Exception("No dump data available")
+    for i, c, l, p, w in zip(input_ids, cu_seqlens, lbl_seq_lens, position_idxs, word_idxs):
+        yield {
+            "input_ids": i,
+            "cu_seqlens": c,
+            "lbl_seqlens": l,
+            "position_ids": p,
+            "word_ids": w
+        }
+
+def get_sahara_426M_dataloader(dp_rank, dp_size, seq_len, tokenizer, mbs: int = 128, world_rank=None):
+    assert seq_len == 4096, "currently for sahara dump it's dumped in 4K fashion for test purpose"
+    if dp_size == 2:
+        print("Using 2 rank sahara dump")
+        input_ids, cu_seqlens, lbl_seq_lens, position_idxs, word_idxs = prepare_data_input_426M_2rank(dp_rank, world_rank, mbs)
+    else:
+        raise Exception("No dump data available")
+    for i, c, l, p, w in zip(input_ids, cu_seqlens, lbl_seq_lens, position_idxs, word_idxs):
+        yield {
+            "input_ids": i,
+            "cu_seqlens": c,
+            "lbl_seqlens": l,
+            "position_ids": p,
+            "word_ids": w
+        }
+
+def moe_extract_weights(rank, expert_num, expert_size, local_experts, vocab_size, hidden_size, dtype, device, layer_number):
+    loading_path = MOE_WEIGHT_PATH
+    if local_experts != expert_num:
+        loading_path = f'{MOE_WEIGHT_EP_PATH}/rank{rank}'
+    vocab_embedding = torch.nn.Linear(hidden_size, vocab_size, dtype=dtype, device=device)
+    logits_embedding = torch.nn.Linear(hidden_size, vocab_size, dtype=dtype, device=device)
+    qkv = [torch.nn.Linear(hidden_size, hidden_size * 3, bias=False, dtype=dtype, device=device) for _ in
+           range(layer_number)]
+    dense = [torch.nn.Linear(hidden_size, hidden_size, bias=False, dtype=dtype, device=device) for _ in
+             range(layer_number)]
+    w1 = [torch.nn.Linear(2 * expert_size * local_experts, hidden_size, bias=False, dtype=dtype, device=device) for _ in
+          range(layer_number)]
+    w2 = [torch.nn.Linear(hidden_size, expert_size * local_experts, bias=False, dtype=dtype, device=device) for _ in
+          range(layer_number)]
+    gate = [torch.nn.Linear(hidden_size, expert_num, bias=False, dtype=dtype, device=device) for _ in
+            range(layer_number)]
+    qkv_rmsnorm_weight = [torch.ones(hidden_size, dtype=dtype, device=device) for _ in range(layer_number)]
+    rmsnorm_weight = [torch.ones(hidden_size, dtype=dtype, device=device) for _ in range(layer_number)]
+
+    # Loading from path:
+    print(f"Loading from path: {loading_path}")
+    vocab_weight = torch.load(f'{loading_path}/vocab_weight.pt').to(device=device)
+    vocab_embedding.weight.data.copy_(vocab_weight.data)
+    for i in range(layer_number):
+        qkv_dump = torch.load(f'{loading_path}/layers.{i}.self_attention.query_key_value.weight.pt').to(device=device)
+        qkv[i].weight.data.copy_(qkv_dump.data)
+        dense_dump = torch.load(f'{loading_path}/layers.{i}.self_attention.dense.weight.pt').to(device=device)
+        dense[i].weight.data.copy_(dense_dump.data)
+        w1_dump = torch.load(f'{loading_path}/layers.{i}.mlp.experts.weight1.pt').to(device=device)
+        w1[i].weight.data.copy_(w1_dump.data)
+        w2_dump = torch.load(f'{loading_path}/layers.{i}.mlp.experts.weight2.pt').to(device=device)
+        w2[i].weight.data.copy_(w2_dump.data)
+        gating_dump = torch.load(f'{loading_path}/layers.{i}.mlp.router.weight.pt').to(device=device)
+        gate[i].weight.data.copy_(gating_dump.data)
+
+    qkv_weights = [a.weight for a in qkv]
+    dense_weights = [a.weight for a in dense]
+    w1_weights = [a.weight for a in w1]
+    w2_weights = [a.weight for a in w2]
+    gate_weights = [a.weight for a in gate]
+    return vocab_embedding.weight, logits_embedding.weight, qkv_weights, dense_weights, w1_weights, w2_weights, gate_weights, qkv_rmsnorm_weight, rmsnorm_weight
+
+
+def extract_weights(vocab_size, hidden_size, inner_size, dtype, device, layer_number, initialize_from_raw=False, num_attention_head: Optional[int] = None, n_shared_qhead: Optional[int] = None):
+    INITIALIZE_RANGE = 0.013975424859373685
+    #INITIALIZE_RANGE = 0.01976423537605237
+    std = INITIALIZE_RANGE / math.sqrt(2 * layer_number)
+    #std = 1e-5
+
+    qkv_size = hidden_size * 3
+    if n_shared_qhead is not None:
+        assert num_attention_head is not None
+        num_gqa_groups = num_attention_head // n_shared_qhead
+        qkv_size = hidden_size + 2 * int(hidden_size * num_gqa_groups // num_attention_head)
+        
+
+    vocab_embedding = torch.nn.Linear(hidden_size, vocab_size, dtype=dtype, device=device)
+    logits_embedding = torch.nn.Linear(hidden_size, vocab_size, dtype=dtype, device=device)
+    final_rmsnorm_weight = torch.ones(hidden_size, dtype=dtype, device=device)
+    qkv = [torch.nn.Linear(hidden_size, qkv_size, bias=False, dtype=dtype, device=device) for _ in
+           range(layer_number)]
+    dense = [torch.nn.Linear(hidden_size, hidden_size, bias=False, dtype=dtype, device=device) for _ in
+             range(layer_number)]
+    w1 = [torch.nn.Linear(hidden_size, 2 * inner_size, bias=False, dtype=dtype, device=device) for _ in
+          range(layer_number)]
+    w2 = [torch.nn.Linear(inner_size, hidden_size, bias=False, dtype=dtype, device=device) for _ in
+          range(layer_number)]
+    qkv_rmsnorm_weight = [torch.ones(hidden_size, dtype=dtype, device=device) for _ in range(layer_number)]
+    rmsnorm_weight = [torch.ones(hidden_size, dtype=dtype, device=device) for _ in range(layer_number)]
+    if initialize_from_raw:
+        print(f"Initializing from Raw with std: {std}...")
+        vocab_embedding.weight.data.normal_(mean=0.0, std=math.sqrt(1.0 / (2 * hidden_size)))
+        logits_embedding.weight.data.normal_(mean=0.0, std=math.sqrt(1.0 / (2 * hidden_size)))
+        for i in range(len(qkv)):
+            qkv[i].weight.data.normal_(mean=0.0, std=INITIALIZE_RANGE)
+            dense[i].weight.data.normal_(mean=0.0, std=std)
+            w1[i].weight.data.normal_(mean=0.0, std=INITIALIZE_RANGE)
+            w2[i].weight.data.normal_(mean=0.0, std=std)
+    else:
+        if n_shared_qhead is not None and n_shared_qhead == 2:
+            WEIGHT_PATH = GQA_WEIGHT_PATH
+        elif (n_shared_qhead is not None and n_shared_qhead == 1) or n_shared_qhead is None:
+            WEIGHT_PATH = NO_GQA_WEIGHT_PATH
+        print(f"Loading from path: {WEIGHT_PATH}")
+        vocab_weight = torch.load(f'{WEIGHT_PATH}/vocab_weight.pt').to(device=device)
+        vocab_embedding.weight.data.copy_(vocab_weight.data)
+        for i in range(layer_number):
+            qkv_dump = torch.load(f'{WEIGHT_PATH}/layers.{i}.self_attention.query_key_value.weight.pt').to(device=device)
+            qkv[i].weight.data.copy_(qkv_dump.data)
+            dense_dump = torch.load(f'{WEIGHT_PATH}/layers.{i}.self_attention.dense.weight.pt').to(device=device)
+            dense[i].weight.data.copy_(dense_dump.data)
+            w1_dump = torch.load(f'{WEIGHT_PATH}/layers.{i}.mlp.fc1_weight.pt').to(device=device)
+            w1[i].weight.data.copy_(w1_dump.data)
+            w2_dump = torch.load(f'{WEIGHT_PATH}/layers.{i}.mlp.fc2_weight.pt').to(device=device)
+            w2[i].weight.data.copy_(w2_dump.data)
+    qkv_weights = [a.weight for a in qkv]
+    dense_weights = [a.weight for a in dense]
+    w1_weights = [a.weight for a in w1]
+    w2_weights = [a.weight for a in w2]
+    return vocab_embedding.weight, final_rmsnorm_weight, logits_embedding.weight, qkv_weights, dense_weights, w1_weights, w2_weights, qkv_rmsnorm_weight, rmsnorm_weight
+
+def extract_layer(layer_number:int, dp_rank:int, pp_rank:int, pp_size: int, phase:int,
+                    vocab_weight,                
+                    logits_weight,
+                    qkv_weight,
+                    dense_weight,
+                    w1_weight,
+                    w2_weight,
+                    gate_weight,
+                    qkv_rmsnorm_weight,
+                    rmsnorm_weight):
+    layer_indices = torch.arange(0, layer_number)
+    split_size = int(pp_size * 2)
+    layer_indices_splitted = torch.split(layer_indices, layer_number // split_size)
+    mid = split_size // 2
+    if phase == 0:
+        layer_indices_first_half = list(layer_indices_splitted[:mid])
+        assert len(layer_indices_first_half) == pp_size
+        my_idx = layer_indices_first_half[pp_rank]     
+        print(f'[DP-rank-{dp_rank}][PP-Rank-{pp_rank}] For FIRST half selecting layer_idx: {my_idx}')   
+        # handling m0.         
+    elif phase == 1:
+        layer_indices_second_half = list(layer_indices_splitted[mid:])
+        layer_indices_second_half.reverse()
+        assert len(layer_indices_second_half) == pp_size
+        my_idx = layer_indices_second_half[pp_rank]        
+        print(f'[DP-rank-{dp_rank}][PP-Rank-{pp_rank}] For SECOND half selecting layer_idx: {my_idx}')   
+    else:
+        raise Exception(f"Unsupported phase number: {phase}")
+    qkvs = [qkv_weight[i] for i in my_idx]
+    denses = [dense_weight[i] for i in my_idx]
+    w1s = [w1_weight[i] for i in my_idx]
+    w2s = [w2_weight[i] for i in my_idx]
+    gates = [gate_weight[i] for i in my_idx]
+    qkv_norms = [qkv_rmsnorm_weight[i] for i in my_idx]
+    norms = [rmsnorm_weight[i] for i in my_idx]
+    return my_idx, vocab_weight, logits_weight, qkvs, denses, w1s, w2s, gates, qkv_norms, norms
+
+
+def moe_nopipe_ckpt_loading(layer_number, vocab_size, hidden_size, expert_num, expert_size, local_experts, dtype, device):
+    def ckpt_callback(m, rank_generator: RankGenerator):
+        (
+            vocab_weight,
+            logits_weight,
+            qkv_weight,
+            dense_weight,
+            w1_weight,
+            w2_weight,
+            gate_weight,
+            qkv_rmsnorm_weight,
+            rmsnorm_weight
+        ) = moe_extract_weights(rank_generator.get_dp_rank(), expert_num, expert_size, local_experts, vocab_size, hidden_size, dtype, device, layer_number)
+
+        m.set_weight(vocab_weight, logits_weight, qkv_weight, qkv_rmsnorm_weight, dense_weight, w1_weight,
+                        w2_weight, gate_weight, rmsnorm_weight)
+
+        del vocab_weight
+        del logits_weight
+        del qkv_weight
+        del dense_weight
+        del w1_weight
+        del w2_weight
+        del qkv_rmsnorm_weight
+        del rmsnorm_weight
+        del gate_weight
+    
+    return ckpt_callback
+
+def moe_dualpipe_ckpt_loading(layer_number, vocab_size, hidden_size, expert_num, expert_size, local_experts, dtype, device):
+    def ckpt_callback(m0, m1, rank_generator: RankGenerator):
+        (
+            vocab_weight,
+            logits_weight,
+            qkv_weight,
+            dense_weight,
+            w1_weight,
+            w2_weight,
+            gate_weight,
+            qkv_rmsnorm_weight,
+            rmsnorm_weight
+        ) = moe_extract_weights(rank_generator.get_dp_rank(), expert_num, expert_size, local_experts, vocab_size, hidden_size, dtype, device, layer_number)
+
+        (
+            offset_slice_m0,
+            vocab_weight_m0,
+            logits_weight_m0,
+            qkv_weight_m0,
+            dense_weight_m0,
+            w1_weight_m0,
+            w2_weight_m0,
+            gate_weight_m0,
+            qkv_rmsnorm_weight_m0,
+            rmsnorm_weight_m0
+        ) = extract_layer(layer_number, rank_generator.get_dp_rank(), rank_generator.get_pp_rank(), rank_generator.get_pp_size(), 0, vocab_weight, logits_weight, qkv_weight, dense_weight, w1_weight, w2_weight, gate_weight, qkv_rmsnorm_weight, rmsnorm_weight)
+
+        (
+            offset_slice_m1,
+            vocab_weight_m1,
+            logits_weight_m1,
+            qkv_weight_m1,
+            dense_weight_m1,
+            w1_weight_m1,
+            w2_weight_m1,
+            gate_weight_m1,
+            qkv_rmsnorm_weight_m1,
+            rmsnorm_weight_m1
+        ) = extract_layer(layer_number, rank_generator.get_dp_rank(), rank_generator.get_pp_rank(), rank_generator.get_pp_size(), 1, vocab_weight, logits_weight, qkv_weight, dense_weight, w1_weight, w2_weight, gate_weight, qkv_rmsnorm_weight, rmsnorm_weight)
+
+        m0.set_weight(vocab_weight_m0, logits_weight_m0, qkv_weight_m0, qkv_rmsnorm_weight_m0, dense_weight_m0, w1_weight_m0,
+                     w2_weight_m0, gate_weight_m0, rmsnorm_weight_m0, global_offset_slice=offset_slice_m0)
+        m1.set_weight(vocab_weight_m1, logits_weight_m1, qkv_weight_m1, qkv_rmsnorm_weight_m1, dense_weight_m1, w1_weight_m1,
+                     w2_weight_m1, gate_weight_m1, rmsnorm_weight_m1, global_offset_slice=offset_slice_m1)
+
+        del offset_slice_m0
+        del vocab_weight_m0
+        del logits_weight_m0
+        del qkv_weight_m0
+        del dense_weight_m0
+        del w1_weight_m0
+        del w2_weight_m0
+        del gate_weight_m0
+        del qkv_rmsnorm_weight_m0
+        del rmsnorm_weight_m0
+
+        del offset_slice_m1
+        del vocab_weight_m1
+        del logits_weight_m1
+        del qkv_weight_m1
+        del dense_weight_m1
+        del w1_weight_m1
+        del w2_weight_m1
+        del gate_weight_m1
+        del qkv_rmsnorm_weight_m1
+        del rmsnorm_weight_m1
+
+        del vocab_weight
+        del logits_weight
+        del qkv_weight
+        del dense_weight
+        del w1_weight
+        del w2_weight
+        del gate_weight
+        del qkv_rmsnorm_weight
+        del rmsnorm_weight
+
+    return ckpt_callback

playground/Abbie-h100/tests/test_aux_loss.py

@@ -0,0 +1,124 @@
+import torch
+import torch.nn.functional as F
+import numpy as np
+from dualpipe.module.gargantua.aux_loss import AuxLoadbalancingLoss, switch_load_balancing_loss_func
+from dualpipe.module.config import GargantuaConfig
+
+torch.manual_seed(42)
+np.random.seed(42)
+
+def test_aux_loss_forward_backward():
+    
+    hidden_size = 1344
+    num_attention_heads = 21
+    config = GargantuaConfig(hidden_size, hidden_size, num_attention_heads)
+    config.moe_router_topk = 2
+    config.moe_aux_loss_coeff = 0.01
+    
+    batch_size = 32
+    num_experts = 4
+    
+    probs = torch.randn(batch_size, num_experts, requires_grad=True)
+    probs_softmax = F.softmax(probs, dim=-1)
+
+    splits = torch.rand(num_experts-1).sort()[0] * (batch_size*config.moe_router_topk)
+    splits = splits.round().int()
+    tokens_per_expert = torch.zeros(num_experts, dtype=torch.int)
+    tokens_per_expert[0] = splits[0]
+    for i in range(1, num_experts-1):
+        tokens_per_expert[i] = splits[i] - splits[i-1]
+    tokens_per_expert[-1] = (batch_size*config.moe_router_topk) - splits[-1]
+
+    activation = torch.randn(batch_size, hidden_size, requires_grad=True)
+    
+    def auto_grad_version():
+        probs_clone = probs_softmax.clone().detach().requires_grad_(True)
+        tokens_clone = tokens_per_expert.clone().detach()
+        act_clone = activation.clone().detach().requires_grad_(True)
+        
+        aux_loss = switch_load_balancing_loss_func(
+            probs_clone, tokens_clone, config.moe_router_topk, config.moe_aux_loss_coeff
+        )
+        
+        scaled_output = act_clone
+        
+        mse_loss = torch.mean(scaled_output ** 2)
+        total_loss = mse_loss + aux_loss
+        
+        total_loss.backward()
+        
+        return {
+            'output': scaled_output.detach(),
+            'aux_loss': aux_loss.detach(),
+            'activation_grad': act_clone.grad.clone(),
+            'probs_grad': probs_clone.grad.clone() if probs_clone.grad is not None else None,
+            'total_loss': total_loss.detach()
+        }
+    
+    def custom_module_version():
+        probs_clone = probs_softmax.clone().detach().requires_grad_(True)
+        tokens_clone = tokens_per_expert.clone().detach()
+        act_clone = activation.clone().detach().requires_grad_(True)
+        
+        output, aux_loss = AuxLoadbalancingLoss.forward(
+            probs_clone, tokens_clone, act_clone, config
+        )
+        
+        mse_loss = torch.mean(output ** 2)
+        total_loss = mse_loss + aux_loss
+        
+        grad_output = 2 * output / output.numel() 
+        
+        grad_probs, grad_tokens, grad_activation, _ = AuxLoadbalancingLoss.backward(
+            grad_output, probs_clone, aux_loss, tokens_clone, 
+            config.moe_router_topk, config.moe_aux_loss_coeff
+        )
+        
+        
+        return {
+            'output': output.detach(),
+            'aux_loss': aux_loss.detach(),
+            'activation_grad': grad_activation,
+            'probs_grad': grad_probs,
+            'total_loss': total_loss.detach()
+        }
+    
+    print("PyTorch AutoGrad:")
+    auto_results = auto_grad_version()
+    # print(auto_results)
+    print("AuxLoadbalancingLoss Function:")
+    custom_results = custom_module_version()
+    
+
+    print("\nDiff forward:")
+    output_diff = torch.max(torch.abs(auto_results['output'] - custom_results['output'])).item()
+    print(f"  max output diff: {output_diff}")
+    
+    aux_loss_diff = torch.abs(auto_results['aux_loss'] - custom_results['aux_loss']).item()
+    print(f"  aux loss diff: {aux_loss_diff}")
+    
+    total_loss_diff = torch.abs(auto_results['total_loss'] - custom_results['total_loss']).item()
+    print(f"  total loss diff: {total_loss_diff}")
+    
+    print("\nDiff backward:")
+    activation_grad_diff = torch.max(torch.abs(auto_results['activation_grad'] - custom_results['activation_grad'])).item()
+    print(f"  activation grad diff: {activation_grad_diff}")
+    
+    if auto_results['probs_grad'] is not None and custom_results['probs_grad'] is not None:
+        probs_grad_diff = torch.max(torch.abs(auto_results['probs_grad'] - custom_results['probs_grad'])).item()
+        print(f"  probs grad diff: {probs_grad_diff}")
+    
+    # check
+    threshold = 1e-5
+    if (output_diff < threshold and 
+        aux_loss_diff < threshold and 
+        total_loss_diff < threshold and 
+        activation_grad_diff < threshold and 
+        (auto_results['probs_grad'] is None or 
+         torch.max(torch.abs(auto_results['probs_grad'] - custom_results['probs_grad'])).item() < threshold)):
+        print("\nPass!")
+    else:
+        print("\nFailed!")
+        
+if __name__ == "__main__":
+    test_aux_loss_forward_backward()

playground/Abbie-h100/tests/test_dense_baseline.py

@@ -0,0 +1,138 @@
+import os
+
+import torch
+import torch.distributed as dist
+
+from torch.optim.lr_scheduler import LambdaLR
+
+import numpy as np
+
+from transformers import AutoTokenizer
+
+from dualpipe.module.parallel_states import build_rank_generator
+from dualpipe.module.config import GargantuaConfig
+from dualpipe.module.baseline.transformer_layer import TransformerLayer
+from dualpipe.module.shared.vocab import vocab_parallel_cross_entropy
+
+from tests.shared.preparation import (
+    extract_weights,
+    get_sahara_58M_dataloader,
+)
+
+from tests.shared.optimizer import (
+    build_optimizer,
+    get_lr_lambda
+)
+
+RANDOM_INPUTS = os.environ.get("RANDOM_INPUTS", "0") == "1"
+TOKENIZER_PATH = '/opt/tiger/tokenizer/bbpe-136k-ml-1227'
+
+torch.manual_seed(42)
+np.random.seed(42)
+
+
+def preprocess_labels(labels, cu_seqlens, pad_idx_tensor):
+    shift_labels = torch.cat((labels[1:], labels.new_ones((1)) * pad_idx_tensor))
+    shift_labels.requires_grad = False
+    lbl_seq_lens = (cu_seqlens[1:] - 1).long()
+    shift_labels[lbl_seq_lens] = pad_idx_tensor
+    shift_labels = shift_labels.unsqueeze(0).transpose(0, 1).contiguous()
+    return shift_labels
+
+def convert_gradients_to_fp32(model):
+    for name, param in model.named_parameters():
+        print(f"Converting model param precision: {name} on address: {id(param)}")
+        if param.grad is not None:
+            print(f"Converted model param precision: {name}")
+            param.grad.data = param.grad.data.float()
+
+
+def main(rank, ngpus, expert_num: int = 32, pp_size: int = 1, vocab_size: int = 136064, inner: int = 5504,
+         hidden_size: int = 2048, num_attention_head: int = 16, layer_number: int = 24, seq_len: int = 4096):
+    torch.cuda.set_device(rank)
+    dist.init_process_group(backend='nccl', init_method="env://", world_size=ngpus, rank=rank)
+    torch.set_default_device(f"cuda:{rank}")
+    tokenizer = AutoTokenizer.from_pretrained(TOKENIZER_PATH)
+    tokenizer.pad_token = tokenizer.eos_token
+
+    device = f'cuda:{rank}'
+    dtype = torch.bfloat16
+    (
+        vocab_weight,
+        logits_weight,
+        qkv_weight,
+        dense_weight,
+        w1_weight,
+        w2_weight,
+        qkv_rmsnorm_weight,
+        rmsnorm_weight
+    ) = extract_weights(vocab_size, hidden_size, inner, dtype, device, layer_number)
+
+    group = dist.distributed_c10d._get_default_group()
+    world_size = group.size()
+    rank_generator = build_rank_generator(rank, world_size, expert_num, 1, pp_size)
+    rank_generator.init()
+    dp_group = rank_generator.get_dp_group()
+    pad_idx_tensor = torch.tensor(1).long().to(device=device)
+    moe_config = (GargantuaConfig(vocab_size, hidden_size, -1, num_attention_head, seq_len, is_moe=False)
+                  .with_dense_inner_size(inner)
+                  .with_tie_weight()
+                  .with_deterministic()
+                  .with_async_comm())
+
+
+    layer = TransformerLayer(rank_generator, config=moe_config, layer_number=layer_number)
+
+    layer.set_weight(vocab_weight, logits_weight, qkv_weight, qkv_rmsnorm_weight, dense_weight, w1_weight,
+                     w2_weight, [], rmsnorm_weight)
+
+    optim = build_optimizer(rank, ngpus, layer, dp_group)
+    scheduler = LambdaLR(optim, lr_lambda=get_lr_lambda(False))
+
+    epoch = 10
+    mbs = 1
+    gbs = 128 // ngpus
+    for e in range(epoch):
+        real_step = 0
+        opt_step = 0
+        for batch in get_sahara_58M_dataloader(rank, ngpus, seq_len, tokenizer):
+            input_id = batch['input_ids']
+            cu_seqlen = batch['cu_seqlens']
+            lbl_seqlen = batch['lbl_seqlens']
+            loss_mask = torch.ones_like(input_id, dtype=torch.int32)
+            loss_mask[0, lbl_seqlen] = 0
+            real_step += 1
+            labels = input_id.clone()
+            total_s = cu_seqlen[-1].item()
+            shift_labels = preprocess_labels(labels.squeeze(), cu_seqlen, pad_idx_tensor)
+            shift_labels.requires_grad = False
+
+            res = layer.forward(input_id, cu_seqlen, total_s)
+            loss_arr = vocab_parallel_cross_entropy(res.float(), shift_labels).transpose(0, 1).contiguous()
+            loss_mask = loss_mask.view(-1).float().to(loss_arr.device)
+            loss_mean = torch.sum(loss_arr.view(-1) * loss_mask) / loss_mask.sum().clamp(min=1)
+            loss = loss_mean / (gbs * ngpus)
+            loss.backward()
+            # non_zero_grad(layer)
+            if real_step % gbs == 0:
+                opt_step += 1
+                seen_token = (opt_step * seq_len * mbs * gbs * ngpus) / 1024.0 / 1024.0  # In M
+                grad_norm = torch.nn.utils.clip_grad_norm_(layer.parameters(), 1)
+                print(
+                    f"[Rank-{rank}] epoch: {e} step: {opt_step} consumed: {seen_token}M tokens Loss_mean: {loss_mean} grad_norm: {grad_norm} lr: {scheduler.get_last_lr()[0]:.3e}")
+                # print(f"[Rank-{rank}] epoch: {e} step: {i} Loss_mean: {loss_mean} grad_norm: {grad_norm}")
+                optim.step()
+                scheduler.step()
+                optim.zero_grad()
+    print("All done")
+
+
+def test_cross_node(ngpus):
+    torch.multiprocessing.spawn(main, args=(ngpus,), nprocs=ngpus, daemon=True)
+
+
+if __name__ == "__main__":
+    num_gpus = torch.cuda.device_count()
+    testing_gpu = 1
+    assert testing_gpu <= num_gpus
+    test_cross_node(testing_gpu)

playground/Abbie-h100/tests/test_dense_gargantua.py

@@ -0,0 +1,166 @@
+import os
+
+import torch
+import torch.distributed as dist
+
+from torch.optim.lr_scheduler import LambdaLR
+
+import numpy as np
+
+from transformers import AutoTokenizer
+from dualpipe.log import WandbLogger
+
+from dualpipe.module.parallel_states import build_rank_generator
+from dualpipe.module.config import GargantuaConfig, OptimizerConfig
+from dualpipe.module.gargantua.transformer_layer import TransformerGargantuaLayer
+from dualpipe.module.shared.vocab import  vocab_parallel_cross_entropy
+from dualpipe.module.shared.optimizer import MixPrecisionDDPOptimizer
+
+from tests.shared.preparation import (
+    extract_weights,
+    get_sahara_58M_dataloader,
+)
+
+from trainer.utils import (
+    collect_scalars_across_data_parallel_group
+)
+
+RANDOM_INPUTS = os.environ.get("RANDOM_INPUTS", "0") == "1"
+TOKENIZER_PATH = '/opt/tiger/tokenizer/bbpe-136k-ml-1227'
+
+torch.manual_seed(42)
+np.random.seed(42)
+
+def preprocess_labels(labels, cu_seqlens, pad_idx_tensor):
+    shift_labels = torch.cat((labels[1:], labels.new_ones((1)) * pad_idx_tensor))
+    shift_labels.requires_grad = False
+    lbl_seq_lens = (cu_seqlens[1:] - 1).long()
+    shift_labels[lbl_seq_lens] = pad_idx_tensor
+    shift_labels = shift_labels.unsqueeze(0).transpose(0, 1).contiguous()
+    return shift_labels
+
+
+def main(rank, dp_size, expert_num: int = 32, pp_size: int = 1, gbs = 128, mbs = 2, vocab_size: int = 136064, inner: int = 5504,
+         hidden_size: int = 2048, num_attention_head: int = 16, n_shared_qhead: int = 1, layer_number: int = 24, seq_len:int = 4096):
+    torch.cuda.set_device(rank)
+    dist.init_process_group(backend='nccl', init_method="env://", world_size=dp_size, rank=rank)
+    torch.set_default_device(f"cuda:{rank}")
+    tokenizer = AutoTokenizer.from_pretrained(TOKENIZER_PATH)
+    tokenizer.pad_token = tokenizer.eos_token
+    db_logger = WandbLogger(rank, None, f"test_gargantua_6_gqa1_mbs{mbs}")
+
+    device = f'cuda:{rank}'
+    dtype = torch.bfloat16
+    (
+        vocab_weight,
+        final_rmsnorm_weight,
+        logits_weight,
+        qkv_weight,
+        dense_weight,
+        w1_weight,
+        w2_weight,
+        qkv_rmsnorm_weight,
+        rmsnorm_weight
+    ) = extract_weights(vocab_size, hidden_size, inner, dtype, device, layer_number, initialize_from_raw=False, num_attention_head=num_attention_head, n_shared_qhead=n_shared_qhead)
+
+    group = dist.distributed_c10d._get_default_group()
+    world_size = group.size()
+    rank_generator = build_rank_generator(rank, world_size, expert_num, 1, pp_size, world_size, local_rank=rank)
+    rank_generator.init()
+    dp_group = rank_generator.get_dp_group()
+    pad_idx_tensor = torch.tensor(1).long().to(device=device)
+    moe_config = (GargantuaConfig(vocab_size, hidden_size, -1, num_attention_head, n_shared_qhead, seq_len, is_moe=False)
+                  .with_dense_inner_size(inner)
+                  .with_tie_weight()
+                  .with_deterministic()
+                  .with_async_comm()
+                  .with_attn_dropout(0.0)
+                  .with_residual_dropout(0.0)
+                  )
+    optimizer_config = OptimizerConfig(
+        total_steps=2034515, warmup_steps=10172.57500, hold_steps=0,
+        lr_max=5e-4, lr_min=5e-5, constant_lr=False, weight_decay=0.1,
+        enable_zero_redundant=True
+    )
+
+    layer = TransformerGargantuaLayer(rank_generator, config=moe_config, layer_number=layer_number, first_stage=True, last_stage=True)
+
+    layer.set_weight(vocab_weight, final_rmsnorm_weight, logits_weight, qkv_weight, qkv_rmsnorm_weight, dense_weight, w1_weight,
+                     w2_weight, [], rmsnorm_weight)    
+
+    del vocab_weight
+    del logits_weight
+    del qkv_weight
+    del dense_weight
+    del w1_weight
+    del w2_weight
+    del qkv_rmsnorm_weight
+    del rmsnorm_weight
+    print(f"Allocated CUDA Memory before configure optimizer: {torch.cuda.memory_allocated() / 1000.0 / 1000 / 1000} GB")
+    optim = MixPrecisionDDPOptimizer(rank, dp_size, layer.dense_parameters(), group, dp_group, optimizer_config)
+    print(f"Allocated CUDA Memory after configure optimizer: {torch.cuda.memory_allocated() / 1000.0 / 1000 / 1000} GB")
+
+    epoch = 1
+    gbs = gbs // (dp_size * mbs)
+
+    real_step = 0
+    opt_step = 0
+    db_logger.set_step(opt_step)
+    for e in range(epoch):
+        real_step = 0
+        opt_step = 0
+        losses = []
+        for batch in get_sahara_58M_dataloader(rank, dp_size, seq_len, tokenizer, mbs=mbs):
+        #for batch in get_thoth_v2_dataloader(rank, ngpus, seq_len, tokenizer):
+            input_id = batch['input_ids']
+            cu_seqlen = batch['cu_seqlens']
+            lbl_seqlen = batch['lbl_seqlens']
+            loss_mask = torch.ones_like(input_id, dtype=torch.int32)
+            loss_mask[0, lbl_seqlen] = 0
+            real_step += 1
+            labels = input_id.clone()
+            total_s = cu_seqlen[-1].item()
+            shift_labels = preprocess_labels(labels.squeeze(), cu_seqlen, pad_idx_tensor)
+            shift_labels.requires_grad = False
+
+            layer.set_input_ctx((cu_seqlen, total_s))
+            #res = layer.forward(input_id, cu_seqlen, total_s)
+            res = layer.forward(input_id)
+            loss_arr = vocab_parallel_cross_entropy(res.float(), shift_labels).transpose(0, 1).contiguous()
+            loss_mask = loss_mask.view(-1).float().to(loss_arr.device)
+            loss_mean = torch.sum(loss_arr.view(-1) * loss_mask) / loss_mask.sum().clamp(min=1)                        
+            loss = loss_mean / gbs
+            losses.append(loss_mean)
+            loss.backward()
+            #accumulate_grads(param_to_master_params)
+            #non_zero_grad(layer)
+            if real_step % gbs == 0:
+                #copy_back_grads(name_to_param_and_master_param)
+                opt_step += 1
+                seen_token = (opt_step * seq_len * mbs * gbs * dp_size) / 1024.0 / 1024.0 # In M
+                #grad_norm = torch.nn.utils.clip_grad_norm_(layer.parameters(), 1)
+                #print(f"[Rank-{rank}] epoch: {e} step: {i} Loss_mean: {loss_mean} grad_norm: {grad_norm}")
+                optim.step()
+                loss_report = sum(losses) / len(losses)
+                gather_objs = collect_scalars_across_data_parallel_group([loss_report], rank_generator.get_dp_group())
+                gathered_loss = sum(gather_objs[0]) / dp_size
+                losses = []          
+                if rank == 0 and opt_step % 1 == 0:
+                    print(f"[Rank-{rank}] epoch: {e} step: {opt_step} consumed: {seen_token}M tokens Loss_mean: {gathered_loss} grad_norm: {optim.grad_norm} lr: {optim.scheduler.get_last_lr()[0]:.3e}")
+                    db_logger.log_step({'training/loss': gathered_loss})
+
+                #scheduler.step()
+                #optim.zero_grad(set_to_none=True)
+                #zero_out_master_grads(name_to_param_and_master_param)
+    print("All done")
+
+def test_cross_node(ngpus):
+    torch.multiprocessing.spawn(main, args=(ngpus,), nprocs=ngpus, daemon=True)
+
+
+if __name__ == "__main__":
+
+    num_gpus = torch.cuda.device_count()
+    testing_gpu = 4
+    assert testing_gpu <= num_gpus
+    test_cross_node(testing_gpu)

playground/Abbie-h100/tests/test_dense_mlp.py

@@ -0,0 +1,123 @@
+import os
+
+import torch
+import torch.distributed as dist
+import numpy as np
+
+from dualpipe.module.parallel_states import RankGenerator, build_rank_generator
+from dualpipe.module.config import GargantuaConfig
+from dualpipe.module.gargantua.transformer_layer import TransformerGargantuaLayer
+from dualpipe.module.baseline.transformer_layer import TransformerLayer
+from dualpipe.module.shared.vocab import vocab_parallel_cross_entropy
+
+RANDOM_INPUTS = os.environ.get("RANDOM_INPUTS", "0") == "1"
+
+torch.manual_seed(42)
+np.random.seed(42)
+from dualpipe.module.debug import MEM
+
+def _extract_weights(inner_size, vocab_size, hidden_size, dtype, device, layer_number):
+    vocab_embedding = torch.nn.Linear(hidden_size, vocab_size, dtype=dtype, device=device)
+    logits_embedding = torch.nn.Linear(hidden_size, vocab_size, dtype=dtype, device=device)
+    qkv = [torch.nn.Linear(hidden_size, hidden_size * 3, bias=False, dtype=dtype, device=device) for _ in
+           range(layer_number)]
+    dense = [torch.nn.Linear(hidden_size, hidden_size, bias=False, dtype=dtype, device=device) for _ in
+             range(layer_number)]
+    w1 = [torch.nn.Linear(hidden_size, 2 * inner_size, bias=False, dtype=dtype, device=device) for _ in
+          range(layer_number)]
+    w2 = [torch.nn.Linear(inner_size, hidden_size, bias=False, dtype=dtype, device=device) for _ in
+          range(layer_number)]
+    qkv_rmsnorm_weight = [torch.ones(hidden_size, dtype=dtype, device=device) for _ in range(layer_number)]
+    rmsnorm_weight = [torch.ones(hidden_size, dtype=dtype, device=device) for _ in range(layer_number)]
+
+    qkv_weights = [a.weight for a in qkv]
+    dense_weights = [a.weight for a in dense]
+    w1_weights = [a.weight for a in w1]
+    w2_weights = [a.weight for a in w2]
+    return vocab_embedding.weight, logits_embedding.weight, qkv_weights, dense_weights, w1_weights, w2_weights, qkv_rmsnorm_weight, rmsnorm_weight
+
+
+def preprocess_labels(labels, cu_seqlens, pad_idx_tensor):
+    shift_labels = torch.cat((labels[1:], labels.new_ones((1))*pad_idx_tensor))
+    shift_labels.requires_grad = False
+    lbl_seq_lens = (cu_seqlens[1:] - 1).long()
+    shift_labels[lbl_seq_lens] = pad_idx_tensor
+    shift_labels = shift_labels.unsqueeze(0).transpose(0, 1).contiguous()
+    return shift_labels
+
+def main(rank, ngpus, vocab_size: int = 136064, inner: int = 8192, hidden_size: int = 4096, expert_size: int = 1536, num_attention_head: int = 32, layer_number: int=2, top_k=8):
+    is_first_rank = rank == 0
+    torch.cuda.set_device(rank)
+    dist.init_process_group(backend='nccl', init_method="env://", world_size=ngpus, rank=rank)
+    torch.set_default_device(f"cuda:{rank}")
+    device = f'cuda:{rank}'
+    dtype = torch.bfloat16
+    (
+        vocab_weight,
+        logits_weight,
+        qkv_weight,
+        dense_weight,
+        w1_weight,
+        w2_weight,
+        qkv_rmsnorm_weight,
+        rmsnorm_weight
+    ) = _extract_weights(inner, vocab_size, hidden_size, dtype, device, layer_number)
+    group = dist.distributed_c10d._get_default_group()
+    world_size = group.size()
+    rank_generator = build_rank_generator(rank, world_size, 1, 1, 1)
+    rank_generator.init()
+    #moe = MoELayer(rank, ep_group, hidden_size, expert_num, top_k=2, ep_rank=ep_rank, ep_size=ep_size)    
+    if not RANDOM_INPUTS:
+        input_ids = torch.load(f'/opt/tiger/DualPipe/sample_data/moe_dump_ids_labels_only/input_ids_rank_1.pt', weights_only=True).to(device=f'cuda:{rank}')
+        cu_seqlens = torch.load(f'/opt/tiger/DualPipe/sample_data/moe_dump_ids_labels_only/cu_seqlens_rank_1.pt', weights_only=True).to(device=f'cuda:{rank}')
+        labels = torch.load(f'/opt/tiger/DualPipe/sample_data/moe_dump_ids_labels_only/labels_1.pt', weights_only=True).to(device=f'cuda:{rank}')
+        pad_idx_tensor = torch.tensor(1).long().to(device=device)
+    else:
+        seq_len = 256
+        cu_seqlens = torch.tensor([0, seq_len], dtype=torch.int32)
+    total_s = cu_seqlens[-1].item()
+    moe_config = (GargantuaConfig(vocab_size, hidden_size, -1, num_attention_head, 4096, is_moe=False)
+                  .with_dense_inner_size(inner)
+                  .with_deterministic()
+                  .with_async_comm())
+
+
+    layer = TransformerGargantuaLayer(rank_generator, config=moe_config, layer_number=layer_number, first_stage=True, last_stage=True)
+    layer_baseline = TransformerLayer(rank_generator, config=moe_config, layer_number=layer_number)
+    layer.set_weight(vocab_weight, logits_weight, qkv_weight, qkv_rmsnorm_weight, dense_weight, w1_weight, w2_weight, [], rmsnorm_weight)
+    layer.set_input_ctx((cu_seqlens, total_s))
+    #layer.set_head_and_tail(True, True)
+    layer_baseline.set_weight(vocab_weight, logits_weight, qkv_weight, qkv_rmsnorm_weight, dense_weight, w1_weight, w2_weight, [], rmsnorm_weight)
+    layer_baseline.prepare()
+    input_ids2 = input_ids.detach().clone()    
+
+    #layer = DDP(ddp_config, layer, rank_generator.get_dp_group())
+
+    shift_labels = preprocess_labels(labels, cu_seqlens, pad_idx_tensor)
+    res2 = layer_baseline.forward(input_ids2, cu_seqlens, total_s)    
+    res = layer.forward(input_ids)
+    MEM.compare()
+    
+    loss = vocab_parallel_cross_entropy(res, shift_labels)
+    loss2 = vocab_parallel_cross_entropy(res2, shift_labels)
+
+    loss = loss.transpose(0, 1).contiguous().mean()
+    loss2 = loss2.transpose(0, 1).contiguous().mean()
+    assert torch.allclose(loss, loss2)
+    loss.backward()
+    loss2.backward()
+    MEM.compare_bwd()
+    MEM.is_bitwise_close()
+    #optim.step()
+    print("All done")
+
+
+def test_cross_node(ngpus):
+    torch.multiprocessing.spawn(main, args=(ngpus,), nprocs=ngpus, daemon=True)
+
+
+if __name__ == "__main__":
+    num_gpus = torch.cuda.device_count()
+    testing_gpu = 4
+    assert testing_gpu <= num_gpus
+    test_cross_node(testing_gpu)

playground/Abbie-h100/tests/test_gemm.py

@@ -0,0 +1,47 @@
+import torch
+
+from dualpipe.module.gargantua.functors import LinearTEFunc
+from abbie_cpp import bf16_gemm_lt
+
+_cublas_workspace = None
+
+
+def get_cublas_workspace_size_bytes() -> None:
+    """Return 32 MiB if using hopper, 4 MiB for all other architectures."""
+    if torch.cuda.get_device_properties(torch.cuda.current_device()).major >= 9:
+        return 33_554_432
+    return 4_194_304
+
+
+def get_workspace() -> torch.Tensor:
+    """Returns workspace for cublas."""
+    global _cublas_workspace
+    if _cublas_workspace is None:
+        _cublas_workspace = torch.empty(get_cublas_workspace_size_bytes(), dtype=torch.uint8, device="cuda")
+    return _cublas_workspace
+
+
+fwd_input = torch.load('/opt/tiger/gemm_test_sample/fwd_inputmat.pt').to(device='cuda:0')
+fwd_weight = torch.load('/opt/tiger/gemm_test_sample/fwd_weight.pt').to(device='cuda:0')
+fwd_output = torch.load('/opt/tiger/gemm_test_sample/fwd_output.pt').to(device='cuda:0')
+
+bwd_grad_output = torch.load('/opt/tiger/gemm_test_sample/bwd_grad_output.pt').to(device='cuda:0')
+bwd_weight = torch.load('/opt/tiger/gemm_test_sample/bwd_weight.pt').to(device='cuda:0')
+bwd_inputmat = torch.load('/opt/tiger/gemm_test_sample/bwd_inputmat.pt').to(device='cuda:0')
+bwd_dgrad = torch.load('/opt/tiger/gemm_test_sample/bwd_dgrad.pt').to(device='cuda:0')
+
+if __name__ == '__main__':
+    out = LinearTEFunc.forward(fwd_input, fwd_weight).squeeze()
+    out2 = bf16_gemm_lt.gemm_bf16_row_major(fwd_input, fwd_weight, trans_a=False, trans_b=True, accumulate=False, accumulate_target=None, workspace=get_workspace())
+    print(torch.nonzero(out - out2))
+
+    bwd_weight_2 = bwd_weight.detach().clone()
+    bwd_weight.main_grad = torch.zeros_like(bwd_weight, dtype=torch.float32)
+    bwd_weight_2.main_grad = torch.zeros_like(bwd_weight_2, dtype=torch.float32)
+
+    dgrad = LinearTEFunc.backward(bwd_grad_output, bwd_inputmat, bwd_weight).squeeze()
+    bf16_gemm_lt.gemm_bf16_row_major(bwd_grad_output, bwd_inputmat, trans_a=True, trans_b=False, accumulate=True, accumulate_target=bwd_weight_2.main_grad, workspace=get_workspace())
+    dgrad_2 = bf16_gemm_lt.gemm_bf16_row_major(bwd_grad_output, bwd_weight_2,  trans_a=False, trans_b=False, accumulate=False, accumulate_target=None, workspace=get_workspace())    
+    print(torch.nonzero(dgrad - dgrad_2))
+    print(torch.nonzero(bwd_weight.main_grad - bwd_weight_2.main_grad))
+

playground/Abbie-h100/tests/test_moe_gargantua.py

@@ -0,0 +1,187 @@
+import os
+import math
+import random
+import torch
+import torch.distributed as dist
+from torch.optim.lr_scheduler import LambdaLR
+
+from dualpipe.deterministic import set_deterministic
+from dualpipe.log import WandbLogger
+import numpy as np
+
+
+set_deterministic(42, False)
+from transformers import AutoTokenizer
+from dualpipe.module.parallel_states import build_rank_generator
+from dualpipe.module.config import GargantuaConfig, OptimizerConfig
+from dualpipe.module.gargantua.transformer_layer import TransformerGargantuaLayer
+from dualpipe.module.shared.vocab import vocab_parallel_cross_entropy
+from dualpipe.module.shared.optimizer import MixPrecisionDDPOptimizer
+from tests.shared.preparation import (
+    # set_deterministic,
+    moe_extract_weights,
+    get_sahara_426M_dataloader,
+)
+from tests.shared.optimizer import (
+    sample_check_pow2_grad
+)
+
+RANDOM_INPUTS = os.environ.get("RANDOM_INPUTS", "0") == "1"
+TOKENIZER_PATH = '/opt/tiger/tokenizer/bbpe-136k-ml-1227'
+
+
+def preprocess_labels(labels, cu_seqlens, pad_idx_tensor):
+    shift_labels = torch.cat((labels[1:], labels.new_ones((1)) * pad_idx_tensor))
+    shift_labels.requires_grad = False
+    lbl_seq_lens = (cu_seqlens[1:] - 1).long()
+    shift_labels[lbl_seq_lens] = pad_idx_tensor
+    shift_labels = shift_labels.unsqueeze(0).transpose(0, 1).contiguous()
+    return shift_labels
+
+
+def collect_scalars_across_data_parallel_group(scalars, dp_group):
+    """Reduce a tensor of losses across all GPUs."""
+    scalars = torch.cat(
+        [loss.clone().detach().view(1) for loss in scalars])
+    group_size = torch.distributed.get_world_size(group=dp_group)
+    out_scalars = [torch.ones_like(scalars) for i in range(group_size)]
+    torch.distributed.all_gather(out_scalars, scalars,
+                                 group=dp_group)
+    return out_scalars, group_size
+
+
+def main(rank, ngpus, expert_num: int = 16, dp_size: int = 2, ep_size: int = 2, pp_size: int = 1,
+         vocab_size: int = 136064, expert_size: int = 640, top_k=2,
+         gbs: int = 128, hidden_size: int = 2048, num_attention_head: int = 16, layer_number: int = 24,
+         seq_len: int = 4096):
+    epoch = 1
+    mbs = 1
+    gbs = gbs // ngpus
+    set_deterministic(42, False)
+
+    torch.cuda.set_device(rank)
+    local_experts = (expert_num // ep_size)
+    dist.init_process_group(backend='nccl', init_method="env://", world_size=ngpus, rank=rank)
+    torch.set_default_device(f"cuda:{rank}")
+    tokenizer = AutoTokenizer.from_pretrained(TOKENIZER_PATH)
+    tokenizer.pad_token = tokenizer.eos_token
+    device = f'cuda:{rank}'
+    dtype = torch.bfloat16
+    (
+        vocab_weight,
+        logits_weight,
+        qkv_weight,
+        dense_weight,
+        w1_weight,
+        w2_weight,
+        gate_weight,
+        qkv_rmsnorm_weight,
+        rmsnorm_weight
+    ) = moe_extract_weights(rank, expert_num, expert_size, local_experts, vocab_size, hidden_size, dtype, device,
+                            layer_number)
+    db_logger = WandbLogger(rank, None, 'abbie_moe_test_gargantua')
+    group = dist.distributed_c10d._get_default_group()
+    world_size = group.size()
+    rank_generator = build_rank_generator(rank, world_size, expert_num, ep_size, pp_size)
+    rank_generator.init()
+    dp_group = rank_generator.get_dp_group()
+    dep_group = rank_generator.get_dep_group()
+    pad_idx_tensor = torch.tensor(1).long().to(device=device)
+    moe_config = (GargantuaConfig(vocab_size, hidden_size, expert_size, num_attention_head, 4096)
+                  .with_gbs(gbs)
+                  .with_ep_size(ep_size)
+                  .with_expert_number(expert_num)
+                  .with_moe_topk(top_k)
+                  .with_tie_weight()
+                  .with_deterministic()
+                  # .with_mlp_checkpoint()
+                  # .with_async_comm()
+                  )
+    moe_config.moe_aux_loss_coeff = 5e-3
+    moe_config.moe_z_loss_coeff = 1e-3
+
+    optimizer_config = OptimizerConfig(
+        total_steps=2034515, warmup_steps=10172.57500, hold_steps=0,
+        lr_max=5e-4, lr_min=5e-5, constant_lr=False, weight_decay=0.1,
+        enable_zero_redundant=True
+    )
+    layer = TransformerGargantuaLayer(rank_generator, config=moe_config, layer_number=layer_number, first_stage=True,
+                                      last_stage=True)
+    # layer = TransformerLayer(rank_generator, config=moe_config, layer_number=layer_number)
+    layer.set_weight(vocab_weight, logits_weight, qkv_weight, qkv_rmsnorm_weight, dense_weight, w1_weight,
+                     w2_weight, gate_weight, rmsnorm_weight)
+    del vocab_weight
+    del logits_weight
+    del qkv_weight
+    del dense_weight
+    del w1_weight
+    del w2_weight
+    del qkv_rmsnorm_weight
+    del rmsnorm_weight
+    del gate_weight
+    print(
+        f"Allocated CUDA Memory before configure optimizer: {torch.cuda.memory_allocated() / 1000.0 / 1000 / 1000} GB")
+    optim1 = MixPrecisionDDPOptimizer(rank, ngpus, layer.dense_parameters(), None, dp_group, optimizer_config)
+    optim2 = MixPrecisionDDPOptimizer(rank, ngpus, layer.moe_parameters(), None, dep_group, optimizer_config)
+    print(f"Allocated CUDA Memory after configure optimizer: {torch.cuda.memory_allocated() / 1000.0 / 1000 / 1000} GB")
+    losses = []
+    for e in range(epoch):
+        real_step = 0
+        opt_step = 0
+        for batch in get_sahara_426M_dataloader(rank, ngpus, seq_len, tokenizer):
+            # for batch in get_thoth_v2_dataloader(rank, ngpus, seq_len, tokenizer):
+            input_id = batch['input_ids']
+            cu_seqlen = batch['cu_seqlens']
+            lbl_seqlen = batch['lbl_seqlens']
+            loss_mask = torch.ones_like(input_id, dtype=torch.int32)
+            loss_mask[0, lbl_seqlen] = 0
+            real_step += 1
+            labels = input_id.clone()
+            total_s = cu_seqlen[-1].item()
+            shift_labels = preprocess_labels(labels.squeeze(), cu_seqlen, pad_idx_tensor)
+            shift_labels.requires_grad = False
+            layer.set_input_ctx((cu_seqlen, total_s))
+            # res = layer.forward(input_id, cu_seqlen, total_s)
+            res = layer.forward(input_id)
+            loss_arr = vocab_parallel_cross_entropy(res.float(), shift_labels).transpose(0, 1).contiguous()
+            loss_mask = loss_mask.view(-1).float().to(loss_arr.device)
+            loss_mean = torch.sum(loss_arr.view(-1) * loss_mask) / loss_mask.sum().clamp(min=1)
+            losses.append(loss_mean.detach().clone())
+            loss = loss_mean / (gbs)
+            loss.backward()
+            # sample_check_pow2_grad(dict(layer.named_parameters()))
+            if real_step % gbs == 0:
+                # copy_back_grads(name_to_param_and_master_param)
+                # layer.scale_main_grad(1.0 / torch.distributed.get_world_size(dp_group))
+                loss_report = sum(losses) / len(losses)
+                gather_objs = collect_scalars_across_data_parallel_group([loss_report], dp_group)
+                gathered_loss = sum(gather_objs[0]) / dp_size
+                losses = []
+                seen_token = (opt_step * seq_len * mbs * gbs * ngpus) / 1024.0 / 1024.0  # In M
+                # grad_norm = torch.nn.utils.clip_grad_norm_(layer.parameters(), 1)
+                # print(f"[Rank-{rank}] epoch: {e} step: {i} Loss_mean: {loss_mean} grad_norm: {grad_norm}")
+                optim1.step()
+                optim2.step()
+                if rank == 0 and opt_step % 1 == 0:
+                    caliberated_grad_norm = math.sqrt(optim1.grad_norm ** 2 + optim2.grad_norm ** 2)
+                    print(
+                        f"[Rank-{rank}] epoch: {e} step: {opt_step} consumed: {seen_token}M tokens Loss: {gathered_loss} grad_norm: {caliberated_grad_norm} lr: {optim1.scheduler.get_last_lr()[0]:.3e}")
+                    db_logger.log_step({
+                        'training/loss': gathered_loss,
+                    })
+                opt_step += 1
+                # scheduler.step()
+                # optim.zero_grad(set_to_none=True)
+                # zero_out_master_grads(name_to_param_and_master_param)
+    print("All done")
+
+
+def test_cross_node(ngpus):
+    torch.multiprocessing.spawn(main, args=(ngpus,), nprocs=ngpus, daemon=True)
+
+
+if __name__ == "__main__":
+    num_gpus = torch.cuda.device_count()
+    testing_gpu = 2
+    assert testing_gpu <= num_gpus
+    test_cross_node(testing_gpu)

playground/Abbie-h100/tests/test_moe_gating.py

@@ -0,0 +1,90 @@
+import torch
+import numpy as np
+from dualpipe.module.config import GargantuaConfig
+from dualpipe.module.gargantua.functors import LinearFunc
+
+torch.manual_seed(42)
+np.random.seed(42)
+
+def test_linear_func_forward_backward():
+    hidden_size = 1344
+    num_attention_heads = 21
+    config = GargantuaConfig(hidden_size, hidden_size, num_attention_heads)
+    config.moe_router_topk = 2
+    config.moe_aux_loss_coeff = 0.01
+    
+    batch_size = 32
+    num_experts = 4
+
+    hidden_states = torch.randn(batch_size, hidden_size, requires_grad=True)
+    gating = torch.randn(num_experts, hidden_size, requires_grad=True)
+
+    expected_shape = (batch_size, num_experts)
+    grad_output = torch.randn(expected_shape)
+    
+    def auto_grad_version():
+
+        input_clone = hidden_states.clone().detach().requires_grad_(True)
+        gating_clone = gating.clone().detach().requires_grad_(True)
+        
+
+        logits = torch.matmul(input_clone, gating_clone.t())
+
+        logits.backward(grad_output.clone())
+        
+        return {
+            'output': logits.detach(),
+            'input_grad': input_clone.grad.clone(),
+            'gating_grad': gating_clone.grad.clone()
+        }
+    
+    def custom_module_version():
+        input_clone = hidden_states.clone().detach().requires_grad_(True)
+        gating_clone = gating.clone().detach().requires_grad_(True)
+        input_fp32 = input_clone.float()
+        gating_clone.grad = None
+        
+        logits = LinearFunc.forward(input_fp32, gating_clone)
+        
+        grad_input = LinearFunc.backward(grad_output.clone(), input_fp32, gating_clone)
+        
+        if input_clone.dtype != input_fp32.dtype:
+            grad_input = grad_input.to(dtype=input_clone.dtype)
+            
+
+        if input_clone.grad is None:
+            input_clone.grad = grad_input
+        else:
+            input_clone.grad += grad_input
+        
+        return {
+            'output': logits.detach(),
+            'input_grad': input_clone.grad.clone(),
+            'gating_grad': gating_clone.grad.clone()
+        }
+    
+    print("Testing:")
+    auto_results = auto_grad_version()
+    custom_results = custom_module_version()
+    
+    print("\nDiff forward:")
+    output_diff = torch.max(torch.abs(auto_results['output'] - custom_results['output'])).item()
+    print(f"  max output diff: {output_diff}")
+    
+    print("\nDiff backward:")
+    input_grad_diff = torch.max(torch.abs(auto_results['input_grad'] - custom_results['input_grad'])).item()
+    print(f"  max input grad diff: {input_grad_diff}")
+    
+    gating_grad_diff = torch.max(torch.abs(auto_results['gating_grad'] - custom_results['gating_grad'])).item()
+    print(f"  gating grad diff: {gating_grad_diff}")
+    
+    threshold = 1e-5
+    if (output_diff < threshold and 
+        input_grad_diff < threshold and 
+        gating_grad_diff < threshold):
+        print("\nPass!")
+    else:
+        print("\nFailed!")
+        
+if __name__ == "__main__":
+    test_linear_func_forward_backward()

playground/Abbie-h100/tests/test_moe_mlp.py

@@ -0,0 +1,142 @@
+import os
+
+import torch
+import torch.distributed as dist
+import numpy as np
+
+from dualpipe.module.parallel_states import RankGenerator, build_rank_generator
+from dualpipe.module.config import GargantuaConfig
+from dualpipe.module.gargantua.transformer_layer import TransformerGargantuaLayer
+from dualpipe.module.baseline.transformer_layer import TransformerLayer
+from dualpipe.module.shared.vocab import vocab_parallel_cross_entropy
+
+RANDOM_INPUTS = os.environ.get("RANDOM_INPUTS", "0") == "1"
+
+torch.manual_seed(42)
+np.random.seed(42)
+from dualpipe.module.debug import MEM
+
+def _extract_weights(expert_num, expert_size, local_experts, vocab_size, hidden_size, dtype, device, layer_number):
+    vocab_embedding = torch.nn.Linear(hidden_size, vocab_size, dtype=dtype, device=device)
+    logits_embedding = torch.nn.Linear(hidden_size, vocab_size, dtype=dtype, device=device)
+    qkv = [torch.nn.Linear(hidden_size, hidden_size * 3, bias=False, dtype=dtype, device=device) for _ in
+           range(layer_number)]
+    dense = [torch.nn.Linear(hidden_size, hidden_size, bias=False, dtype=dtype, device=device) for _ in
+             range(layer_number)]
+    w1 = [torch.nn.Linear(hidden_size, 2 * expert_size * local_experts, bias=False, dtype=dtype, device=device) for _ in
+          range(layer_number)]
+    w2 = [torch.nn.Linear(expert_size * local_experts, hidden_size, bias=False, dtype=dtype, device=device) for _ in
+          range(layer_number)]
+    gate = [torch.nn.Linear(hidden_size, expert_num, bias=False, dtype=torch.float32, device=device) for _ in
+            range(layer_number)]
+    qkv_rmsnorm_weight = [torch.ones(hidden_size, dtype=dtype, device=device) for _ in range(layer_number)]
+    rmsnorm_weight = [torch.ones(hidden_size, dtype=dtype, device=device) for _ in range(layer_number)]
+
+    qkv_weights = [a.weight for a in qkv]
+    dense_weights = [a.weight for a in dense]
+    w1_weights = [a.weight for a in w1]
+    w2_weights = [a.weight for a in w2]
+    gate_weights = [a.weight for a in gate]
+    return vocab_embedding.weight, logits_embedding.weight, qkv_weights, dense_weights, w1_weights, w2_weights, gate_weights, qkv_rmsnorm_weight, rmsnorm_weight
+
+
+def preprocess_labels(labels, cu_seqlens, pad_idx_tensor):
+    shift_labels = torch.cat((labels[1:], labels.new_ones((1))*pad_idx_tensor))
+    shift_labels.requires_grad = False
+    lbl_seq_lens = (cu_seqlens[1:] - 1).long()
+    shift_labels[lbl_seq_lens] = pad_idx_tensor
+    shift_labels = shift_labels.unsqueeze(0).transpose(0, 1).contiguous()
+    return shift_labels
+
+def main(rank, ngpus, expert_num: int = 32, ep_size: int = 2, pp_size: int = 2, vocab_size: int = 136064, hidden_size: int = 4096, expert_size: int = 1536, num_attention_head: int = 32, layer_number: int=1, top_k=8):
+    is_first_rank = rank == 0
+    local_experts = (expert_num // ep_size)
+    torch.cuda.set_device(rank)
+    dist.init_process_group(backend='nccl', init_method="env://", world_size=ngpus, rank=rank)
+    torch.set_default_device(f"cuda:{rank}")
+    attention_dropout = 0.0
+    device = f'cuda:{rank}'
+    dtype = torch.bfloat16
+    (
+        vocab_weight,
+        logits_weight,
+        qkv_weight,
+        dense_weight,
+        w1_weight,
+        w2_weight,
+        gate_weight,
+        qkv_rmsnorm_weight,
+        rmsnorm_weight
+    ) = _extract_weights(expert_num, expert_size, local_experts, vocab_size, hidden_size, dtype, device, layer_number)
+    group = dist.distributed_c10d._get_default_group()
+    world_size = group.size()
+    rank_generator = build_rank_generator(rank, world_size, expert_num, ep_size, pp_size)
+    rank_generator.init()
+    #moe = MoELayer(rank, ep_group, hidden_size, expert_num, top_k=2, ep_rank=ep_rank, ep_size=ep_size)    
+    if not RANDOM_INPUTS:
+        input_ids = torch.load(f'/opt/tiger/DualPipe/sample_data/moe_dump_ids_labels_only/input_ids_rank_1.pt', weights_only=True).to(device=f'cuda:{rank}')
+        cu_seqlens = torch.load(f'/opt/tiger/DualPipe/sample_data/moe_dump_ids_labels_only/cu_seqlens_rank_1.pt', weights_only=True).to(device=f'cuda:{rank}')
+        labels = torch.load(f'/opt/tiger/DualPipe/sample_data/moe_dump_ids_labels_only/labels_1.pt', weights_only=True).to(device=f'cuda:{rank}')
+        pad_idx_tensor = torch.tensor(1).long().to(device=device)
+    else:
+        seq_len = 256
+        cu_seqlens = torch.tensor([0, seq_len], dtype=torch.int32)
+    total_s = cu_seqlens[-1].item()
+    moe_config = (GargantuaConfig(vocab_size, hidden_size, expert_size, num_attention_head, 4096)
+              .with_ep_size(ep_size)
+              .with_expert_number(expert_num)
+              .with_moe_topk(top_k)
+              #.with_tie_weight()
+              .with_deterministic()
+              #.with_mlp_checkpoint()
+              .with_async_comm())
+
+    #ddp_config = DistributedDataParallelConfig()
+    #ddp_config.use_distributed_optimizer = True    
+
+    layer = TransformerGargantuaLayer(rank_generator, config=moe_config, layer_number=layer_number, first_stage=True, last_stage=True)
+    layer_baseline = TransformerLayer(rank_generator, config=moe_config, layer_number=layer_number)
+    layer.set_weight(vocab_weight, logits_weight, qkv_weight, qkv_rmsnorm_weight, dense_weight, w1_weight, w2_weight, gate_weight, rmsnorm_weight)
+    layer.set_input_ctx((cu_seqlens, total_s))
+    layer.set_head_and_tail(True, True)
+    layer_baseline.set_weight(vocab_weight, logits_weight, qkv_weight, qkv_rmsnorm_weight, dense_weight, w1_weight, w2_weight, gate_weight, rmsnorm_weight)
+    layer_baseline.prepare()
+    input_ids2 = input_ids.detach().clone()    
+
+    #layer = DDP(ddp_config, layer, rank_generator.get_dp_group())
+    #optim = build_optimizer(layer)
+
+    shift_labels = preprocess_labels(labels, cu_seqlens, pad_idx_tensor)
+    res = layer.forward(input_ids)
+    res2 = layer_baseline.forward(input_ids2, cu_seqlens, total_s)    
+    MEM.compare()
+    
+    loss = vocab_parallel_cross_entropy(res, shift_labels)
+    loss2 = vocab_parallel_cross_entropy(res2, shift_labels)
+
+    loss = loss.transpose(0, 1).contiguous().mean()
+    loss2 = loss2.transpose(0, 1).contiguous().mean()
+    assert torch.allclose(loss, loss2)
+    loss.backward()
+    loss2.backward(retain_graph=True)
+    MEM.compare_bwd()
+    MEM.is_bitwise_close()
+    #optim.step()
+    print("All done")
+
+
+def test_cross_node(ngpus):
+    torch.multiprocessing.spawn(main, args=(ngpus,), nprocs=ngpus, daemon=True)
+
+
+if __name__ == "__main__":
+    #d_qkv = torch.load('/opt/tiger/d_qkv.pt')
+    #qkv_inputmat = torch.load('/opt/tiger/qkv_inputmat.pt')
+    #qkv_rmsnorm_weight = torch.load('/opt/tiger/qkv_rmsnorm_weight.pt')
+    #qkv_rsigma = torch.load('/opt/tiger/qkv_rsigma.pt')
+    #RMSNormFunction.backward(d_qkv, qkv_inputmat, qkv_rmsnorm_weight, qkv_rsigma, d_qkv.shape, False)
+
+    num_gpus = torch.cuda.device_count()
+    testing_gpu = 4
+    assert testing_gpu <= num_gpus
+    test_cross_node(testing_gpu)

playground/Abbie-h100/tests/test_moe_route.py

@@ -0,0 +1,162 @@
+import torch
+import numpy as np
+from tests.shared.moe_route import MoERouterFunc
+from dualpipe.module.config import GargantuaConfig
+from dualpipe.module.shared.moe_utils import switch_load_balancing_loss_func
+
+torch.manual_seed(42)
+np.random.seed(42)
+
+def test_moe_route_forward_backward():
+    
+    hidden_size = 1344
+    num_attention_heads = 21
+    config = GargantuaConfig(hidden_size, hidden_size, num_attention_heads)
+    config.moe_router_topk = 3
+    config.moe_aux_loss_coeff = 0.01
+    config.moe_router_load_balancing_type = "aux_loss"
+    config.moe_input_jitter_eps = None
+    
+    batch_size = 512
+    num_experts = 4
+    
+    # 创建输入数据
+    hidden_states = torch.randn(batch_size, hidden_size, requires_grad=True, dtype=torch.bfloat16).to("cuda:0")
+    gating = torch.randn(num_experts, hidden_size, requires_grad=True,dtype=torch.bfloat16).to("cuda:0")
+    
+    def auto_grad_version():
+        hidden_clone = hidden_states.clone().detach().requires_grad_(True)
+        gating_clone = gating.clone().detach().requires_grad_(True)
+        
+        # 前向计算
+        input_fp32 = hidden_clone.float()
+        logits = torch.nn.functional.linear(input_fp32, gating_clone.to(dtype=input_fp32.dtype))
+        logits = logits.view(-1, num_experts)
+        
+        # TopK softmax
+        scores, top_indices = torch.topk(logits, k=config.moe_router_topk, dim=1)
+        probs = torch.softmax(scores, dim=-1, dtype=torch.float32)
+        
+        # 计算每个专家的token数量
+        tokens_per_expert = torch.bincount(top_indices.view(-1), minlength=num_experts)
+        
+        # 应用负载均衡损失
+        scores_softmax = torch.softmax(logits, dim=-1, dtype=torch.float32)
+        aux_loss = switch_load_balancing_loss_func(
+            scores_softmax, tokens_per_expert, config.moe_router_topk, config.moe_aux_loss_coeff
+        )
+        
+        # 模拟输出
+        output = probs
+        
+        # 计算损失并反向传播
+        mse_loss = torch.mean(output ** 2)
+        total_loss = mse_loss + aux_loss
+        
+        total_loss.backward()
+        
+        return {
+            'output': output.detach(),
+            'aux_loss': aux_loss.detach(),
+            'logits': logits.detach(),
+            'hidden_grad': hidden_clone.grad.clone() if hidden_clone.grad is not None else None,
+            'gating_grad': gating_clone.grad.clone() if gating_clone.grad is not None else None,
+            'total_loss': total_loss.detach()
+        }
+    
+    def custom_module_version():
+        hidden_clone = hidden_states.clone().detach().requires_grad_(True)
+        gating_clone = gating.clone().detach().requires_grad_(True)
+        
+        # 使用自定义的前向传播
+        probs, indices, aux_loss, input_fp32, gating_weight, input_shape, top_k_dim, logits = MoERouterFunc.forward(
+            hidden_clone, gating_clone, num_experts, config
+        )
+        
+        output = probs
+        
+        # 计算损失
+        mse_loss = torch.mean(output ** 2)
+        total_loss = mse_loss + aux_loss
+        
+        # 计算梯度
+        grad_output = 2 * output / output.numel()
+        
+        # 使用自定义的反向传播
+        tokens_per_expert = torch.bincount(indices.view(-1), minlength=num_experts)
+        grad_hidden, grad_gating, _, _, _ = MoERouterFunc.backward(
+            grad_output, probs, aux_loss, tokens_per_expert, config,
+            indices, input_shape, top_k_dim, input_fp32, gating_clone, logits
+        )
+        
+        # 注意：我们不能直接获取gating_grad，因为MoERouterFunc.backward不会直接修改gating.grad
+        # 因此我们将比较hidden_states的梯度而非gating的梯度
+        
+        return {
+            'output': output.detach(),
+            'aux_loss': aux_loss.detach(),
+            'logits': logits.detach(),
+            'hidden_grad': grad_hidden,
+            'gating_grad': grad_gating, 
+            'total_loss': total_loss.detach()
+        }
+    
+    print("运行PyTorch AutoGrad版本...")
+    auto_results = auto_grad_version()
+    
+    print("运行自定义MoERouterFunc版本...")
+    custom_results = custom_module_version()
+    
+    print("\n前向传播对比:")
+    output_diff = torch.max(torch.abs(auto_results['output'] - custom_results['output'])).item()
+    print(f"  输出差异最大值: {output_diff}")
+    logits_diff = torch.max(torch.abs(auto_results['logits'] - custom_results['logits'])).item()
+    print(f"  logits差异最大值: {logits_diff}")
+    
+    aux_loss_diff = torch.abs(auto_results['aux_loss'] - custom_results['aux_loss']).item()
+    print(f"  辅助损失差异: {aux_loss_diff}")
+    
+    total_loss_diff = torch.abs(auto_results['total_loss'] - custom_results['total_loss']).item()
+    print(f"  总损失差异: {total_loss_diff}")
+    
+    print("\n反向传播对比:")
+    if auto_results['hidden_grad'] is not None and custom_results['hidden_grad'] is not None:
+        hidden_grad_diff = torch.max(torch.abs(auto_results['hidden_grad'] - custom_results['hidden_grad'])).item()
+        print(f"  hidden_states梯度差异最大值: {hidden_grad_diff}")
+    else:
+        print("  无法比较hidden_states梯度（至少有一个为None）")
+
+    if auto_results['gating_grad'] is not None and custom_results['gating_grad'] is not None:
+        gating_grad_diff = torch.max(torch.abs(auto_results['gating_grad'] - custom_results['gating_grad'])).item()
+        print(f"  gating梯度差异最大值: {gating_grad_diff}")
+    else:
+        print("  无法比较gating梯度（至少有一个为None）")
+    
+    # 检查差异是否在阈值范围内
+    threshold = 1e-5
+    all_passed = True
+    
+    if output_diff >= threshold:
+        all_passed = False
+        print(f"输出差异超过阈值: {output_diff} >= {threshold}")
+    
+    if aux_loss_diff >= threshold:
+        all_passed = False
+        print(f"辅助损失差异超过阈值: {aux_loss_diff} >= {threshold}")
+    
+    if total_loss_diff >= threshold:
+        all_passed = False
+        print(f"总损失差异超过阈值: {total_loss_diff} >= {threshold}")
+    
+    if auto_results['hidden_grad'] is not None and custom_results['hidden_grad'] is not None:
+        if hidden_grad_diff >= threshold:
+            all_passed = False
+            print(f"hidden_states梯度差异超过阈值: {hidden_grad_diff} >= {threshold}")
+    
+    if all_passed:
+        print("\n测试通过！自定义前向/反向传播与PyTorch AutoGrad结果一致")
+    else:
+        print("\n测试失败！自定义前向/反向传播与PyTorch AutoGrad结果不一致")
+        
+if __name__ == "__main__":
+    test_moe_route_forward_backward()

playground/Abbie-h100/tests/test_qwen2_layer.py

@@ -0,0 +1,215 @@
+import argparse
+
+import torch
+from transformers import Qwen2Config
+from transformers.models.qwen2.modeling_qwen2 import Qwen2DecoderLayer, Qwen2RotaryEmbedding
+
+from abbie.gargantua.config import GenericTransformerConfig
+from abbie.gargantua.functional import GargantuaLayerFunc
+from abbie.gargantua.layer import GenericTransformerLayer
+from abbie.utils.deterministic_utils import set_deterministic
+
+
+def make_config() -> Qwen2Config:
+    # Qwen2.5-7B configs
+    return Qwen2Config(
+        attention_dropout=0.0,
+        bos_token_id=151643,
+        eos_token_id=151645,
+        hidden_act="silu",
+        hidden_size=3584,
+        initializer_range=0.02,
+        intermediate_size=18944,
+        max_position_embeddings=32768,
+        max_window_layers=28,
+        num_attention_heads=28,
+        num_hidden_layers=28,
+        num_key_value_heads=4,
+        rms_norm_eps=1e-06,
+        rope_theta=1000000.0,
+        sliding_window=131072,
+        tie_word_embeddings=False,
+        torch_dtype="bfloat16",
+        use_cache=True,
+        use_sliding_window=False,
+        vocab_size=152064,
+        attn_implementation="flash_attention_2",
+    )
+
+
+def zero_grads(layer: Qwen2DecoderLayer):
+    for param in layer.parameters():
+        param.grad = None
+
+
+def gather_grads(layer: Qwen2DecoderLayer):
+    grads = {}
+    for name, param in layer.named_parameters():
+        grads[name] = param.grad
+    return grads
+
+
+def compare_tensors(
+    a: torch.Tensor,
+    b: torch.Tensor,
+    name: str = "tensor",
+) -> torch.Tensor:
+    hidden_size = a.size(-1)
+    sims = torch.nn.functional.cosine_similarity(
+        a.reshape(-1, hidden_size),
+        b.reshape(-1, hidden_size),
+        dim=-1,
+    )
+    diff = a - b
+    print(
+        f"{name} "
+        f"min={sims.min().item():.3f} "
+        f"mean={sims.mean().item():.3f} "
+        f"ratio_diff={diff.nonzero().size(0) / diff.numel():.3f} "
+        f"max_diff={diff.abs().max().item():.3e}"
+    )
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-s", "--seqlen", type=int, default=4 << 10)
+    parser.add_argument(
+        "--deterministic",
+        action="store_true",
+        help="Use deterministic algo",
+    )
+    parser.add_argument(
+        "--compile",
+        action="store_true",
+        help="Compile layer (only effective for hf)",
+    )
+    parser.add_argument("--use_liger", action="store_true")
+
+    parser.add_argument("--recompute_norm", action="store_true")
+    parser.add_argument("--recompute_attn_up_proj", action="store_true")
+    parser.add_argument("--recompute_attn", action="store_true")
+    parser.add_argument("--recompute_mlp", action="store_true")
+    parser.add_argument("--recompute_mlp_act", action="store_true")
+    parser.add_argument("--recompute_dispatch", action="store_true")
+    parser.add_argument("--activation_offloading", action="store_true")
+
+    args = parser.parse_args()
+    print(args)
+
+    if args.deterministic:
+        set_deterministic()
+
+    if args.use_liger:
+        from liger_kernel.transformers import apply_liger_kernel_to_qwen2
+        apply_liger_kernel_to_qwen2()
+
+    # Init model
+    config = make_config()
+    hf_layer = Qwen2DecoderLayer(config=config, layer_idx=0)
+    rotary_emb = Qwen2RotaryEmbedding(config, device="cuda")
+    hf_layer.train().to(torch.bfloat16).cuda()
+
+    if args.compile:
+        hf_layer.compile(dynamic=True)
+
+    # Make some dummy data
+    seqlen = args.seqlen
+    input_tensor = torch.randn(1, seqlen, config.hidden_size, dtype=torch.bfloat16, device="cuda")
+    position_ids = torch.arange(seqlen, dtype=torch.long, device="cuda")[None]
+    attention_mask = torch.ones_like(position_ids)
+
+    position_embeddings = rotary_emb(input_tensor, position_ids)
+    cu_seqlens = torch.tensor([0, seqlen], dtype=torch.int32, device="cuda")
+    max_seqlen = cu_seqlens.diff().max()
+
+    d_output_tensor = torch.randn_like(input_tensor)
+    input_tensor = input_tensor.detach().requires_grad_(True)
+
+    # Calculate reference grads
+    output_tensor_hf = hf_layer(
+        hidden_states=input_tensor,
+        attention_mask=attention_mask,
+        position_ids=position_ids,
+        position_embeddings=position_embeddings,
+        cumulative_seqlens_q=cu_seqlens,
+        cumulative_seqlens_k=cu_seqlens,
+        max_length_q=max_seqlen,
+        max_length_k=max_seqlen,
+    )
+    if isinstance(output_tensor_hf, tuple):
+        output_tensor_hf = output_tensor_hf[0]
+
+    torch.cuda.synchronize()
+    input_tensor.grad = None
+    zero_grads(hf_layer)
+    torch.autograd.backward((output_tensor_hf,), (d_output_tensor,))
+
+    torch.cuda.synchronize()
+    hf_grads = gather_grads(hf_layer)
+    hf_grads["input_tensor"] = input_tensor.grad
+
+    # Build gargantua layer
+    gg_config = GenericTransformerConfig(
+        dp_group=None,
+        pp_group=None,
+        ep_group=None,
+        vocab_size=config.vocab_size,
+        hidden_size=config.hidden_size,
+        intermediate_size=config.intermediate_size,
+        num_hidden_layers=config.num_hidden_layers,
+        num_attention_heads=config.num_attention_heads,
+        num_key_value_heads=config.num_key_value_heads,
+        max_position_embeddings=config.max_position_embeddings,
+        rms_norm_eps=config.rms_norm_eps,
+        tie_word_embeddings=config.tie_word_embeddings,
+        rope_theta=config.rope_theta,
+        use_qkv_bias=True,
+        use_o_bias=False,
+        use_mlp_gate_up_bias=False,
+        use_mlp_down_bias=False,
+        pad_token_id=config.pad_token_id,
+        head_size=None,
+        dtype=torch.bfloat16,
+        recompute_norm=args.recompute_norm,
+        recompute_attn_up_proj=args.recompute_attn_up_proj,
+        recompute_attn=args.recompute_attn,
+        recompute_mlp=args.recompute_mlp,
+        recompute_mlp_act=args.recompute_mlp_act,
+        recompute_dispatch=args.recompute_dispatch,
+        activation_offloading=args.activation_offloading,
+    )
+    gg_layer = GenericTransformerLayer(gg_config)
+    gg_layer.load_state_dict(hf_layer.state_dict())
+
+    gg_layer.train().to(torch.bfloat16).cuda()
+    gg_layer.requires_grad_(True)
+
+    # Calculate gargantua grads
+    ctx, output_tensor_gargantua = GargantuaLayerFunc.apply_module(
+        layer=gg_layer,
+        x=input_tensor,
+        cos=position_embeddings[0],
+        sin=position_embeddings[1],
+        cu_seqlens=cu_seqlens,
+        max_seqlen=max_seqlen,
+        global_num_tokens=attention_mask.ne(0).sum().item(),
+    )
+
+    torch.cuda.synchronize()
+    input_tensor.grad = None
+    zero_grads(gg_layer)
+    torch.autograd.backward((output_tensor_gargantua,), (d_output_tensor,))
+
+    torch.cuda.synchronize()
+    gg_grads = gather_grads(gg_layer)
+    gg_grads["input_tensor"] = input_tensor.grad
+
+    # Now compare outputs and grads
+    compare_tensors(output_tensor_hf, output_tensor_gargantua, name="output_tensor")
+    for name, hf_grad in hf_grads.items():
+        gg_grad = gg_grads[name]
+        compare_tensors(hf_grad, gg_grad, name=name)
+
+
+if __name__ == "__main__":
+    main()

playground/Abbie-h100/tests/test_qwen3_moe_layer.py

@@ -0,0 +1,383 @@
+import argparse
+
+import torch
+import torch.distributed as dist
+import torch.nn.functional as F
+from transformers import Qwen3MoeConfig
+from transformers.models.qwen3_moe.modeling_qwen3_moe import Qwen3MoeDecoderLayer, Qwen3MoeRotaryEmbedding
+
+from abbie.device_mesh_manager import DMM, init_distributed_env
+from abbie.gargantua.config import GenericTransformerConfig
+from abbie.gargantua.functional import GargantuaLayerFunc
+from abbie.gargantua.layer import GenericTransformerLayer
+from abbie.models.qwen3_moe import Qwen3MoeForCausalLMAbbie
+from abbie.utils.deterministic_utils import set_deterministic
+
+
+def patched_sparse_moe_forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+    """ """
+    batch_size, sequence_length, hidden_dim = hidden_states.shape
+    hidden_states = hidden_states.view(-1, hidden_dim)
+    # router_logits: (batch * sequence_length, n_experts)
+    router_logits = self.gate(hidden_states)
+
+    routing_weights = F.softmax(router_logits, dim=1, dtype=torch.float)
+    routing_weights, selected_experts = torch.topk(routing_weights, self.top_k, dim=-1)
+    if self.norm_topk_prob:  # only diff with mixtral sparse moe block!
+        routing_weights /= routing_weights.sum(dim=-1, keepdim=True)
+    # we cast back to the input dtype
+    routing_weights = routing_weights.to(hidden_states.dtype)
+
+    # final_hidden_states = torch.zeros(
+    #     (batch_size * sequence_length, hidden_dim), dtype=hidden_states.dtype, device=hidden_states.device
+    # )
+    debug_hidden_states = hidden_states.new_zeros(*routing_weights.shape, hidden_dim)
+
+    # One hot encode the selected experts to create an expert mask
+    # this will be used to easily index which expert is going to be sollicitated
+    expert_mask = torch.nn.functional.one_hot(selected_experts, num_classes=self.num_experts).permute(2, 1, 0)
+
+    # Loop over all available experts in the model and perform the computation on each expert
+    expert_hit = torch.greater(expert_mask.sum(dim=(-1, -2)), 0).nonzero()
+    for expert_idx in expert_hit:
+        expert_layer = self.experts[expert_idx]
+        idx, top_x = torch.where(expert_mask[expert_idx].squeeze(0))
+
+        # Index the correct hidden states and compute the expert hidden state for
+        # the current expert. We need to make sure to multiply the output hidden
+        # states by `routing_weights` on the corresponding tokens (top-1 and top-2)
+        current_state = hidden_states[None, top_x].reshape(-1, hidden_dim)
+        # current_hidden_states = expert_layer(current_state) * routing_weights[top_x, idx, None]
+
+        # However `index_add_` only support torch tensors for indexing so we'll use
+        # the `top_x` tensor here.
+        # final_hidden_states.index_add_(0, top_x, current_hidden_states.to(hidden_states.dtype))
+        debug_hidden_states[top_x, idx] = expert_layer(current_state) * routing_weights[top_x, idx, None]
+    # final_hidden_states = final_hidden_states.reshape(batch_size, sequence_length, hidden_dim)
+    final_hidden_states = debug_hidden_states.sum(1)
+    return final_hidden_states, router_logits
+
+
+def load_hf_layer():
+    from liger_kernel.transformers import apply_liger_kernel_to_qwen3_moe
+
+    apply_liger_kernel_to_qwen3_moe()
+
+    # Qwen3MoeSparseMoeBlock.forward = patched_sparse_moe_forward
+
+    # Copied configs from qwen3-30b-a3b
+    config = Qwen3MoeConfig(
+        attention_bias=False,
+        attention_dropout=0.0,
+        bos_token_id=151643,
+        decoder_sparse_step=1,
+        eos_token_id=151645,
+        head_dim=128,
+        hidden_act="silu",
+        hidden_size=2048,
+        initializer_range=0.02,
+        intermediate_size=6144,
+        max_position_embeddings=40960,
+        max_window_layers=48,
+        mlp_only_layers=[],
+        moe_intermediate_size=768,
+        norm_topk_prob=True,
+        num_attention_heads=32,
+        num_experts=128,
+        num_experts_per_tok=8,
+        num_hidden_layers=48,
+        num_key_value_heads=4,
+        output_router_logits=False,
+        rms_norm_eps=1e-06,
+        rope_scaling=None,
+        rope_theta=1000000.0,
+        router_aux_loss_coef=0.001,
+        sliding_window=None,
+        tie_word_embeddings=False,
+        torch_dtype="bfloat16",
+        transformers_version="4.51.0",
+        use_cache=False,
+        use_sliding_window=False,
+        vocab_size=151936,
+        attn_implementation="flash_attention_2",
+    )
+    layer = Qwen3MoeDecoderLayer(config, layer_idx=0)
+    layer.train().to(torch.bfloat16).cuda()
+
+    # Sync parameter values
+    for param in layer.parameters():
+        dist.broadcast(param.data, src=0)
+
+    return config, layer
+
+
+def make_gg_layer(
+    hf_config: Qwen3MoeConfig,
+    hf_layer: Qwen3MoeDecoderLayer,
+    **kwargs,
+):
+    config = Qwen3MoeForCausalLMAbbie.convert_hf_config(
+        hf_config=hf_config,
+        dp_group=DMM.dp_group,
+        pp_group=DMM.pp_group,
+        ep_group=DMM.ep_group,
+        ep_dp_group=DMM.ep_dp_group,
+        sp_group=DMM.sp_group,
+        pp_x_sp_group=DMM.pp_x_sp_group,
+        **kwargs,
+    )
+
+    layer = GenericTransformerLayer(config, layer_idx=0)
+    layer.train().cuda()
+
+    # Hard code the param loading
+    layer.input_layernorm.load_state_dict(hf_layer.input_layernorm.state_dict())
+    layer.self_attn.load_state_dict(hf_layer.self_attn.state_dict())
+    layer.post_attention_layernorm.load_state_dict(hf_layer.post_attention_layernorm.state_dict())
+
+    layer.moe.router.load_state_dict(hf_layer.mlp.gate.state_dict())
+
+    expert_start_idx = config.num_routed_experts_per_rank * config.ep_group.rank()
+    expert_end_idx = config.num_routed_experts_per_rank + expert_start_idx
+    local_experts = hf_layer.mlp.experts[expert_start_idx:expert_end_idx]
+
+    gate_up_weight = torch.stack(
+        [torch.cat([e.gate_proj.weight.detach(), e.up_proj.weight.detach()], dim=0) for e in local_experts]
+    )
+    layer.moe.experts_gate_up_proj_weight.data.copy_(gate_up_weight)
+
+    layer.moe.experts_down_proj_weight.data.copy_(torch.stack([e.down_proj.weight.detach() for e in local_experts]))
+
+    return config, layer
+
+
+def zero_grads(module: torch.nn.Module):
+    for param in module.parameters():
+        param.grad = None
+
+
+def gather_grads(layer: torch.nn.Module):
+    grads = {}
+    for name, param in layer.named_parameters():
+        grads[name] = param.grad
+    return grads
+
+
+def compare_tensors(
+    a: torch.Tensor,
+    b: torch.Tensor,
+    name: str = "tensor",
+) -> torch.Tensor:
+    assert a.shape == b.shape, f"{name} {a.shape} {b.shape}"
+    hidden_size = a.size(-1)
+    sims = torch.nn.functional.cosine_similarity(
+        a.reshape(-1, hidden_size),
+        b.reshape(-1, hidden_size),
+        dim=-1,
+    )
+    diff = a - b
+    print(
+        f"{name} "
+        f"min={sims.min().item():.3f} "
+        f"mean={sims.mean().item():.3f} "
+        f"mean={sims.mean().item():.3f} "
+        f"ratio_diff={diff.nonzero().size(0) / diff.numel():.3f} "
+        f"max_diff={diff.abs().max().item():.3e}"
+    )
+
+
+def test_qwen3_moe_layer(
+    seqlen: int = 4096,
+    recompute_norm: bool = False,
+    recompute_attn_up_proj: bool = False,
+    recompute_attn: bool = False,
+    recompute_attn_down_proj: bool = False,
+    recompute_mlp: bool = False,
+    recompute_mlp_act: bool = False,
+    recompute_dispatch: bool = False,
+    token_dispatch_method: str = "all-to-all",
+):
+    hf_config, hf_layer = load_hf_layer()
+    gg_config, gg_layer = make_gg_layer(
+        hf_config,
+        hf_layer,
+        recompute_norm=recompute_norm,
+        recompute_attn_up_proj=recompute_attn_up_proj,
+        recompute_attn=recompute_attn,
+        recompute_attn_down_proj=recompute_attn_down_proj,
+        recompute_mlp=recompute_mlp,
+        recompute_mlp_act=recompute_mlp_act,
+        recompute_dispatch=recompute_dispatch,
+        token_dispatch_method=token_dispatch_method,
+    )
+    rotary_emb = Qwen3MoeRotaryEmbedding(hf_config, device="cuda")
+
+    if token_dispatch_method == "deep-ep":
+        from abbie.ops.deep_ep import setup_deep_ep_buffer
+
+        setup_deep_ep_buffer(
+            group=DMM.ep_group,
+            hidden_bytes=gg_config.hidden_size * 2,
+            num_sms=20,
+        )
+
+    elif token_dispatch_method == "hybrid-ep":
+        from abbie.ops.hybrid_ep import setup_hybrid_ep_buffer
+
+        setup_hybrid_ep_buffer(
+            ep_group=DMM.ep_group,
+            hidden_dim=gg_config.hidden_size,
+            max_num_of_tokens_per_rank=seqlen,
+            num_local_experts=gg_config.num_routed_experts_per_rank,
+        )
+
+    expert_start_idx = gg_config.num_routed_experts_per_rank * gg_config.ep_group.rank()
+    expert_end_idx = gg_config.num_routed_experts_per_rank + expert_start_idx
+    local_experts = hf_layer.mlp.experts[expert_start_idx:expert_end_idx]
+
+    # Make some dummy data
+    input_tensor = torch.randn(1, seqlen, gg_config.hidden_size, dtype=torch.bfloat16, device="cuda")
+    position_ids = torch.arange(seqlen, dtype=torch.long, device="cuda")[None]
+    attention_mask = torch.ones_like(position_ids)
+
+    position_embeddings = rotary_emb(input_tensor, position_ids)
+    cu_seqlens = torch.tensor([0, seqlen], dtype=torch.int32, device="cuda")
+    max_seqlen = cu_seqlens.diff().max()
+
+    d_output_tensor = torch.randn_like(input_tensor)
+    input_tensor = input_tensor.detach_().requires_grad_(True)
+
+    # Run for huggingface
+    output_tensor_hf = hf_layer(
+        hidden_states=input_tensor,
+        attention_mask=attention_mask,
+        position_ids=position_ids,
+        position_embeddings=position_embeddings,
+        cumulative_seqlens_q=cu_seqlens,
+        cumulative_seqlens_k=cu_seqlens,
+        max_length_q=max_seqlen,
+        max_length_k=max_seqlen,
+    )
+
+    torch.cuda.synchronize()
+    input_tensor.grad = None
+    zero_grads(hf_layer)
+    torch.autograd.backward((output_tensor_hf,), (d_output_tensor,))
+    output_tensor_hf = output_tensor_hf.detach()
+
+    torch.cuda.synchronize()
+    hf_grads = gather_grads(hf_layer)
+    hf_grads["input_tensor"] = input_tensor.grad
+
+    # For comparing with gg later
+    hf_grads["moe.router.weight"] = hf_layer.mlp.gate.weight.grad
+    # hf_grads["moe.experts_gate_proj_weight"] = torch.stack([e.gate_proj.weight.grad.detach() for e in local_experts])
+    # hf_grads["moe.experts_up_proj_weight"] = torch.stack([e.up_proj.weight.grad.detach() for e in local_experts])
+
+    hf_grads["moe.experts_gate_up_proj_weight"] = torch.stack(
+        [torch.cat([e.gate_proj.weight.grad.detach(), e.up_proj.weight.grad.detach()], dim=0) for e in local_experts]
+    )
+    hf_grads["moe.experts_down_proj_weight"] = torch.stack([e.down_proj.weight.grad.detach() for e in local_experts])
+    hf_grads["moe.experts_gate_up_proj_weight"] *= DMM.ep_size
+    hf_grads["moe.experts_down_proj_weight"] *= DMM.ep_size
+
+    input_tensor.grad = None
+    zero_grads(hf_layer)
+
+    # Run for gargantua
+    ctx, output_tensor_gg = GargantuaLayerFunc.apply_module(
+        layer=gg_layer,
+        x=input_tensor[0],
+        cos=position_embeddings[0],
+        sin=position_embeddings[1],
+        cu_seqlens=cu_seqlens,
+        max_seqlen=max_seqlen,
+        global_num_tokens=seqlen,
+    )
+    output_tensor_gg = output_tensor_gg[None]
+
+    ctx.tensors.keys()
+
+    with torch.no_grad():
+        hf_post_attn_states = (
+            input_tensor
+            + hf_layer.self_attn(
+                hidden_states=hf_layer.input_layernorm(input_tensor),
+                attention_mask=attention_mask,
+                position_ids=position_ids,
+                position_embeddings=position_embeddings,
+                cumulative_seqlens_q=cu_seqlens,
+                cumulative_seqlens_k=cu_seqlens,
+                max_length_q=max_seqlen,
+                max_length_k=max_seqlen,
+            )[0]
+        )
+        gg_post_attn_states = ctx.tensors["post_attn_states"].detach().clone()
+        # copy_of_ctx_tensors = {k: v for k, v in ctx.tensors.items()}
+        if dist.get_rank() == 0:
+            compare_tensors(hf_post_attn_states, gg_post_attn_states[None], "post attn states")
+
+    torch.cuda.synchronize()
+    input_tensor.grad = None
+    zero_grads(gg_layer)
+    torch.autograd.backward((output_tensor_gg,), (d_output_tensor,))
+    output_tensor_gg = output_tensor_gg.detach().clone()
+
+    torch.cuda.synchronize()
+    gg_grads = gather_grads(gg_layer)
+    gg_grads["input_tensor"] = input_tensor.grad
+
+    input_tensor.grad = None
+    zero_grads(gg_layer)
+
+    with torch.no_grad():
+        for i in range(dist.get_world_size()):
+            if i == dist.get_rank():
+                print(f"# rank={dist.get_rank()}")
+                compare_tensors(output_tensor_hf, output_tensor_gg, "output_tensor")
+
+                for name, gg_grad in gg_grads.items():
+                    if name in hf_grads:
+                        hf_grad = hf_grads[name]
+                        compare_tensors(gg_grad, hf_grad, name)
+
+                    else:
+                        print(f"Skip {name}")
+
+            dist.barrier()
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--seqlen", type=int, default=4096)
+    parser.add_argument("--ep", type=int, default=1)
+
+    parser.add_argument("--recompute_norm", action="store_true")
+    parser.add_argument("--recompute_attn_up_proj", action="store_true")
+    parser.add_argument("--recompute_attn", action="store_true")
+    parser.add_argument("--recompute_attn_down_proj", action="store_true")
+    parser.add_argument("--recompute_mlp", action="store_true")
+    parser.add_argument("--recompute_mlp_act", action="store_true")
+    parser.add_argument("--recompute_dispatch", action="store_true")
+
+    parser.add_argument("--token-dispatch-method", type=str, default="all-to-all")
+
+    args = parser.parse_args()
+
+    init_distributed_env(ep_size=args.ep)
+    set_deterministic()
+    test_qwen3_moe_layer(
+        seqlen=args.seqlen,
+        recompute_norm=args.recompute_norm,
+        recompute_attn_up_proj=args.recompute_attn_up_proj,
+        recompute_attn=args.recompute_attn,
+        recompute_attn_down_proj=args.recompute_attn_down_proj,
+        recompute_mlp=args.recompute_mlp,
+        recompute_mlp_act=args.recompute_mlp_act,
+        recompute_dispatch=args.recompute_dispatch,
+        token_dispatch_method=args.token_dispatch_method,
+    )
+
+
+if __name__ == "__main__":
+    main()

playground/Abbie-h100/tests/test_swiglu.py

@@ -0,0 +1,129 @@
+import torch
+
+from abbie.ops.kernels.swiglu import packed_silu_mul_backward, packed_silu_mul_forward
+from abbie.utils.deterministic_utils import set_deterministic
+from tests.utils import compare_tensors
+
+
+def torch_silu_mul(gate_up: torch.Tensor) -> torch.Tensor:
+    """Naive reference implementation for comparison."""
+    gate, up = gate_up.chunk(2, -1)
+    return torch.nn.functional.silu(gate) * up
+
+
+def test_forward():
+    """
+    Compare kernel output vs naive PyTorch implementation.
+    Tests: Correctness of forward computation.
+    """
+    torch.manual_seed(42)
+    dtype = torch.bfloat16
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+
+    hidden_size = 1024
+    seqlen = 4096
+
+    # Generate random input [seqlen, hidden_size*2]
+    gate_up = torch.randn(seqlen, hidden_size * 2, dtype=dtype, device=device)
+
+    # Kernel forward
+    _, out_kernel = packed_silu_mul_forward(gate_up.clone())
+
+    # Reference forward
+    out_torch = torch_silu_mul(gate_up)
+
+    # Compare
+    ratio = compare_tensors(out_kernel, out_torch, atol=1e-3, rtol=1e-3)
+    assert ratio > 0.95, f"Forward pass: {ratio * 100:.2f}% values match, expected >95%"
+    print(f"PASS test_forward: {ratio * 100:.2f}% values match")
+
+
+def test_backward():
+    """
+    Compare kernel gradients vs autograd reference.
+    Tests: Correctness of backward gradient computation.
+    """
+    torch.manual_seed(42)
+    dtype = torch.bfloat16
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+
+    hidden_size = 1024
+    seqlen = 4096
+
+    # Generate random inputs
+    gate_up_orig = torch.randn(seqlen, hidden_size * 2, dtype=dtype, device=device, requires_grad=True)
+    dout = torch.randn(seqlen, hidden_size, dtype=dtype, device=device)
+
+    # REFERENCE: Autograd version
+    gate_up_ref = gate_up_orig.clone().detach().requires_grad_(True)
+    gate_ref, up_ref = gate_up_ref.chunk(2, dim=-1)
+    out_ref = torch.nn.functional.silu(gate_ref) * up_ref
+    loss_ref = (out_ref * dout).sum()
+    loss_ref.backward()
+    dgate_up_ref = gate_up_ref.grad.clone()
+
+    # KERNEL: Run backward (clone since it's in-place)
+    gate_up_kernel = gate_up_orig.clone().detach()
+    dgate_up_kernel = packed_silu_mul_backward(gate_up_kernel, dout)
+
+    # Extract dgate and dup components
+    dgate_ref, dup_ref = dgate_up_ref.chunk(2, dim=-1)
+    dgate_kernel, dup_kernel = dgate_up_kernel.chunk(2, dim=-1)
+
+    # Compare gradients
+    print("Comparing dgate:")
+    dgate_ratio = compare_tensors(dgate_kernel, dgate_ref, atol=1e-2, rtol=1e-2)
+    print("Comparing dup:")
+    dup_ratio = compare_tensors(dup_kernel, dup_ref, atol=1e-2, rtol=1e-2)
+
+    assert dgate_ratio > 0.90, f"Backward gate: {dgate_ratio * 100:.2f}% match, expected >90%"
+    assert dup_ratio > 0.90, f"Backward up: {dup_ratio * 100:.2f}% match, expected >90%"
+    print(f"PASS test_backward: dgate {dgate_ratio * 100:.2f}%, dup {dup_ratio * 100:.2f}%")
+
+
+def test_batch_invariant():
+    """
+    Verify that batched[i] == individual row i (exact bitwise match).
+    Tests: Kernel correctly handles different batch dimensions.
+    """
+    set_deterministic()
+    torch.manual_seed(42)
+    dtype = torch.bfloat16
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+
+    hidden_size = 1024
+    seqlen = 4096
+    batch_size = 64
+
+    # Generate batched input [batch_size, seqlen, hidden_size*2]
+    gate_up_batched = torch.randn(batch_size, seqlen, hidden_size * 2, dtype=dtype, device=device)
+
+    # Run forward on batched tensor
+    _, out_batched = packed_silu_mul_forward(gate_up_batched)
+
+    # Run forward on individual rows and stack
+    out_individual = []
+    for i in range(batch_size):
+        _, out_i = packed_silu_mul_forward(gate_up_batched[i : i + 1])
+        out_individual.append(out_i)
+    out_individual = torch.cat(out_individual, dim=0)
+
+    # Require exact bitwise equality
+    assert torch.equal(out_batched, out_individual), "Batch invariant: Expected exact bitwise match"
+    print("PASS test_batch_invariant: Exact bitwise match confirmed")
+
+
+if __name__ == "__main__":
+    print("Running test_forward...")
+    test_forward()
+    print()
+
+    print("Running test_backward...")
+    test_backward()
+    print()
+
+    print("Running test_batch_invariant...")
+    test_batch_invariant()
+    print()
+
+    print("All tests passed!")

playground/Abbie-h100/tests/test_ulysses.py

@@ -0,0 +1,92 @@
+import torch
+import torch.distributed as dist
+
+from abbie.ops.ulysses import ulysses_all_to_all
+
+
+def test_ulysses():
+    dist.init_process_group(backend="nccl")
+    rank = dist.get_rank()
+    world_size = dist.get_world_size()
+
+    torch.cuda.set_device(rank)
+    device = torch.device("cuda", rank)
+
+    num_tokens = 16
+    num_heads = 8
+    head_dim = 64
+
+    if rank == 0:
+        q_full = torch.randn(num_tokens, num_heads, head_dim, device=device)
+        k_full = torch.randn(num_tokens, num_heads, head_dim, device=device)
+        v_full = torch.randn(num_tokens, num_heads, head_dim, device=device)
+    else:
+        q_full = torch.empty(num_tokens, num_heads, head_dim, device=device)
+        k_full = torch.empty(num_tokens, num_heads, head_dim, device=device)
+        v_full = torch.empty(num_tokens, num_heads, head_dim, device=device)
+
+    dist.broadcast(q_full, src=0)
+    dist.broadcast(k_full, src=0)
+    dist.broadcast(v_full, src=0)
+
+    num_tokens_local = num_tokens // world_size
+    q_local = q_full.chunk(world_size, dim=0)[rank].clone()
+    k_local = k_full.chunk(world_size, dim=0)[rank].clone()
+    v_local = v_full.chunk(world_size, dim=0)[rank].clone()
+
+    print(f"Rank {rank}: Local input shape: {q_local.shape}")
+
+    q_gathered, h1 = ulysses_all_to_all(q_local, scatter_dim=-2, group=dist.group.WORLD)
+    k_gathered, h2 = ulysses_all_to_all(k_local, scatter_dim=-2, group=dist.group.WORLD)
+    v_gathered, h3 = ulysses_all_to_all(v_local, scatter_dim=-2, group=dist.group.WORLD)
+    h1.wait()
+    h2.wait()
+    h3.wait()
+
+    q_gathered = q_gathered.flatten(0, 1)
+    k_gathered = k_gathered.flatten(0, 1)
+    v_gathered = v_gathered.flatten(0, 1)
+
+    print(f"Rank {rank}: After pre-attn all-to-all shape: {q_gathered.shape}")
+
+    num_heads_local = num_heads // world_size
+    head_start = rank * num_heads_local
+    head_end = (rank + 1) * num_heads_local
+
+    expected_q = q_full[:, head_start:head_end, :]
+    expected_k = k_full[:, head_start:head_end, :]
+    expected_v = v_full[:, head_start:head_end, :]
+
+    assert torch.allclose(q_gathered, expected_q), f"Rank {rank}: q mismatch after pre-attn"
+    assert torch.allclose(k_gathered, expected_k), f"Rank {rank}: k mismatch after pre-attn"
+    assert torch.allclose(v_gathered, expected_v), f"Rank {rank}: v mismatch after pre-attn"
+
+    print(f"Rank {rank}: Pre-attn all-to-all verified ✓")
+
+    q_reconstructed, h4 = ulysses_all_to_all(q_gathered, scatter_dim=-3, group=dist.group.WORLD)
+    k_reconstructed, h5 = ulysses_all_to_all(k_gathered, scatter_dim=-3, group=dist.group.WORLD)
+    v_reconstructed, h6 = ulysses_all_to_all(v_gathered, scatter_dim=-3, group=dist.group.WORLD)
+    h4.wait()
+    h5.wait()
+    h6.wait()
+
+    q_reconstructed = q_reconstructed.permute(1, 0, 2, 3).flatten(1, 2)
+    k_reconstructed = k_reconstructed.permute(1, 0, 2, 3).flatten(1, 2)
+    v_reconstructed = v_reconstructed.permute(1, 0, 2, 3).flatten(1, 2)
+
+    print(f"Rank {rank}: After post-attn all-to-all shape: {q_reconstructed.shape}")
+
+    assert torch.allclose(q_reconstructed, q_local), f"Rank {rank}: q round-trip mismatch"
+    assert torch.allclose(k_reconstructed, k_local), f"Rank {rank}: k round-trip mismatch"
+    assert torch.allclose(v_reconstructed, v_local), f"Rank {rank}: v round-trip mismatch"
+
+    print(f"Rank {rank}: Post-attn all-to-all (round-trip) verified ✓")
+
+    if rank == 0:
+        print("\nAll tests passed! ✓")
+
+    dist.destroy_process_group()
+
+
+if __name__ == "__main__":
+    test_ulysses()

playground/Abbie-h100/tests/utils.py

@@ -0,0 +1,38 @@
+import torch
+
+
+def compare_tensors(
+    a: torch.Tensor,
+    b: torch.Tensor,
+    atol: float = 1e-5,
+    rtol: float = 1e-5,
+) -> float:
+    """
+    Compare two tensors and return the ratio of matching values.
+
+    Args:
+        a, b: Tensors to compare
+        atol, rtol: Absolute and relative tolerance thresholds
+
+    Returns:
+        ratio: Float between 0.0 and 1.0 indicating fraction of close values
+    """
+    mask = torch.isclose(a, b, atol=atol, rtol=rtol)
+    matching = mask.sum().item()
+    total = mask.numel()
+    ratio = matching / total
+
+    # Log mismatches for debugging
+    if ratio < 1.0:
+        not_close_count = total - matching
+        pct_not_close = (not_close_count / total) * 100
+        print(f"  {pct_not_close:.2f}% of values not close ({not_close_count}/{total})")
+
+        # Show details if small number of mismatches
+        if not_close_count <= 10:
+            mismatches = torch.where(torch.logical_not(mask))
+            print(f"  Mismatch indices: {mismatches}")
+            print(f"  Actual:   {a[mismatches]}")
+            print(f"  Expected: {b[mismatches]}")
+
+    return ratio

playground/Abbie-h100/torchrun/run_dense_pp_and_dp.sh

@@ -0,0 +1,18 @@
+# Below is just a sample for pure cmd line launching. 
+# For debug purpose plz refer to launch.json: torch_dense_pipeline
+
+NCCL_DEBUG=WARN MASTER_ADDR=$ARNOLD_WORKER_0_HOST MASTER_PORT=$ARNOLD_WORKER_0_PORT torchrun \
+--node_rank=$ARNOLD_ID --nproc_per_node=8 --nnodes=1 --rdzv_endpoint=$ARNOLD_WORKER_0_HOST:$ARNOLD_WORKER_0_PORT \
+/opt/tiger/Abbie/trainer/dense_trainer.py \
+--model=1b2.yaml \
+--pp_size=2 \
+--trial_name=abbie_dense_1b2_1T_gbs128_gargantua_pp2_ckpt_UT1_b1 \
+--train_home_path=hdfs://harunava/home/byte_tteng_llm/users/yuyifeng.oscar/pretrain \
+--train_dataset=hdfs://harunava/home/byte_tteng_llm/data/final_datasets/thoth_v3.5_8T_1127_mix34/a6dac3f1/train \
+--train_size=1000000000000 \
+--tokenizer=hdfs://harunava/home/byte_tteng_llm/user/thoth/tokenizer/bbpe-136k-ml-1227 \
+--pad_idx=1 --vocab_size=136064 \
+--global_batch_size=128 --micro_batch_size=1 --warmup_batch_ratio=0.005 \
+--max_seq_len=4096 --max_position_embeddings=4096 --stride=3840 \
+--lr_max=5e-4 --lr_min=5e-5 --lr_weight_decay=0.1 \
+--ckpt_every_n_step=2000

playground/Abbie-h100/torchrun/run_dense_pure_dp.sh

@@ -0,0 +1,17 @@
+# Below is just a sample for pure cmd line launching. 
+# For debug purpose plz refer to launch.json: torch_dense_gargantua 
+
+NCCL_DEBUG=WARN MASTER_ADDR=$ARNOLD_WORKER_0_HOST MASTER_PORT=$ARNOLD_WORKER_0_PORT torchrun \
+--node_rank=$ARNOLD_ID --nproc_per_node=4 --nnodes=1 --rdzv_endpoint=$ARNOLD_WORKER_0_HOST:$ARNOLD_WORKER_0_PORT \
+/opt/tiger/Abbie/trainer/dense_trainer.py \
+--model=1b2.yaml \
+--trial_name=abbie_dense_1b2_1T_gbs128_gargantua_nopp_ckpt_UT1_b1 \
+--train_home_path=hdfs://harunava/home/byte_tteng_llm/users/yuyifeng.oscar/pretrain \
+--train_dataset=hdfs://harunava/home/byte_tteng_llm/data/final_datasets/thoth_v3.5_8T_1127_mix34/a6dac3f1/train \
+--train_size=1000000000000 \
+--tokenizer=hdfs://harunava/home/byte_tteng_llm/user/thoth/tokenizer/bbpe-136k-ml-1227 \
+--pad_idx=1 --vocab_size=136064 \
+--global_batch_size=128 --micro_batch_size=1 --warmup_batch_ratio=0.005 \
+--max_seq_len=4096 --max_position_embeddings=4096 --stride=3840 \
+--lr_max=5e-4 --lr_min=5e-5 --lr_weight_decay=0.1 \
+--ckpt_every_n_step=2000

playground/Abbie-h100/torchrun/run_moe_pp.sh

@@ -0,0 +1 @@
+NCCL_DEBUG=WARN MASTER_ADDR=$ANORLD_WORKER_0_HOST MASTER_PORT=$PORT0 torchrun --node_rank=0 --nproc_per_node=8 --nnodes=1 --rdzv_endpoint=$ARNOLD_WORKER_0_HOST:$PORT0 /opt/tiger/Abbie/torchrun/torchrun_dualpipe_moe_v.py

playground/Abbie-h100/torchrun/run_moe_pure_dp.sh

@@ -0,0 +1 @@
+NCCL_DEBUG=WARN MASTER_ADDR=$ANORLD_WORKER_0_HOST MASTER_PORT=$PORT0 torchrun --node_rank=0 --nproc_per_node=8 --nnodes=1 --rdzv_endpoint=$ARNOLD_WORKER_0_HOST:$PORT0 /opt/tiger/Abbie/torchrun/torchrun_moe_gargantua.py

playground/Abbie-h100/torchrun/torch_sanity.py

@@ -0,0 +1,14 @@
+import os
+import torch
+
+if __name__ == "__main__":
+    rank = int(os.environ['RANK'])
+    local_rank = int(os.environ['LOCAL_RANK'])
+    world_size = int(os.environ['WORLD_SIZE'])
+    visible_devices = os.environ['CUDA_VISIBLE_DEVICES']
+    print(f"[SANITY] rank: {rank}, local_rank: {local_rank}, world_size: {world_size}, visible_device: {visible_devices}")
+    device = torch.device('cuda', local_rank)
+    torch.distributed.init_process_group(backend='nccl', init_method="env://", world_size=world_size, rank=rank, device_id=device)
+    group = torch.distributed.distributed_c10d._get_default_group()
+    group.barrier()
+    print("[SANITY] exiting ..")

playground/Abbie-h100/torchrun/torchrun_dense_gargantua_ckpt.py

@@ -0,0 +1,250 @@
+import os
+
+import math
+import time
+from typing import Optional
+from contextlib import nullcontext
+
+import torch
+import torch.distributed as dist
+
+from einops import rearrange
+from dualpipe.log import WandbLogger
+from dualpipe.deterministic import set_deterministic
+
+import numpy as np
+
+from dualpipe.module.shared.loss import preprocess_labels
+
+set_deterministic(42, False)
+
+from dualpipe.module.shared.vocab import vocab_parallel_cross_entropy
+from dualpipe.module.trainer_builder import build_dense_trainer, build_dense_dataloader_only
+
+RANDOM_INPUTS = os.environ.get("RANDOM_INPUTS", "0") == "1"
+TOKENIZER_PATH = '/opt/tiger/tokenizer/bbpe-136k-ml-1227'
+
+torch.manual_seed(42)
+np.random.seed(42)
+
+_DEFAULT_LOCAL_DIR = '/opt/tiger/Abbie/profiles'
+
+def make_handler(rank, local_dir):
+    def handler_fn(p):
+        # export trace data when traces ready (schedule cycle ends)
+        fname = "profileStep" + str(p.step_num) + "_globalStep" + str(0) + "_rank" + str(rank) + "." + \
+            str(int(time.time())) + ".pt.trace.json.gz"
+        local_file = os.path.join(local_dir, fname)
+        if not os.path.exists(local_dir):
+            print("mkdir ", local_dir)
+            os.makedirs(local_dir)
+        print("Save profile results to {}".format(local_file))
+        p.export_chrome_trace(local_file)
+        print("Local profile file saved")
+    return handler_fn
+
+
+def collect_scalars_across_data_parallel_group(scalars, dp_group):
+    """Reduce a tensor of losses across all GPUs."""
+    scalars = torch.cat(
+        [loss.clone().detach().view(1) for loss in scalars])
+    group_size = torch.distributed.get_world_size(group=dp_group)
+    out_scalars = [torch.ones_like(scalars) for i in range(group_size)]
+    torch.distributed.all_gather(out_scalars, scalars,
+                                 group=dp_group)
+    return out_scalars, group_size
+
+def do_main(rank, local_rank, world_size,
+            pp_size: int = 1,
+            vocab_size: int = 136064, hidden_size: int = 4096, inner: int=5504,
+            seq_len:int = 4096, max_position_embeddings: int = 4096, stride=3840,
+            resume_ckpt_path: Optional[str] = None,
+            gbs: int = 128, num_attention_head: int = 64, layer_number: int = 24, 
+            enable_profiler: bool = False, profiler_step: int = 20, dump_dataloader_step: int= 20):
+    epoch = 1
+    mbs = 1
+    gbs = gbs // world_size
+    set_deterministic(42, False)
+
+    assert world_size % pp_size == 0
+    dp_size = world_size // pp_size
+
+    dist.init_process_group(backend='nccl', init_method="env://", world_size=world_size, rank=rank)
+ 
+    device = f'cuda:{local_rank}'
+    dtype = torch.bfloat16    
+
+    db_logger = WandbLogger(rank, None, 'abbie_dense_1b2_1T_gbs128_gargantua_nopp_ckpt_UT1_b1_ckpt20')
+    group = dist.distributed_c10d._get_default_group()
+    world_size = group.size()
+
+    rank_generator, layer, train_dataloader, optimizers = build_dense_trainer(
+        rank=rank, local_rank=local_rank, world_size=world_size,
+        epoch_number=epoch,
+        train_path='hdfs://harunava/home/byte_tteng_llm/data/final_datasets/thoth_v3.5_8T_1127_mix34/a6dac3f1/train',
+        val_path='hdfs://harunava/home/byte_tteng_llm/data/final_datasets/thoth_v2_2T_0427_with_domain/032e19a9/val',
+        train_size=1000000000000, val_size=-1, warmup_step_rate=0.005,
+        tokenizer_path='hdfs://harunava/home/byte_tteng_llm/user/thoth/tokenizer/bbpe-136k-ml-1227', pad_idx=1,
+        global_batch_size=gbs, micro_batch_size=1,
+        max_seqlen=seq_len, max_position_embeddings=max_position_embeddings, stride=stride,
+        lr_max=5e-4, lr_min=5e-5, weight_decay=0.1,
+        dp_size=dp_size, pp_size=pp_size, 
+        layer_number=layer_number, vocab_size=vocab_size, hidden_size=hidden_size, num_attention_head=num_attention_head, inner=inner,
+        is_deterministic=True,
+    )
+    
+    losses = []
+    total_step = 0
+    profiler_end_step = profiler_step + 10
+    if enable_profiler > 0:
+        prof = torch.profiler.profile(
+                            schedule=torch.profiler.schedule(wait=profiler_step, warmup=2, active=1, repeat=0),
+                            on_trace_ready=make_handler(rank, _DEFAULT_LOCAL_DIR),
+                            record_shapes=True,
+                            profile_memory=True,
+                            with_modules=True,
+                            with_stack=int(torch.__version__[0])>=2)
+    else:
+        prof = nullcontext()
+    train_dataloader_iter = iter(train_dataloader)
+    with prof:
+        for i in range(train_dataloader.length):
+        #for batches in train_dataloader_iter:
+            batches = next(train_dataloader)
+            start_time = time.perf_counter()
+            for batch in batches:
+                input_ids = batch['input_ids'].to(device=device)
+                cu_seqlen = batch['host_seqlens'].to(device=device)
+                word_idx = batch['word_idx'].to(device=device)
+                labels = batch['labels'].to(device=device)            
+                loss_mask = batch['rmpad_loss_mask'].to(device=device)
+                input_ids = rearrange(input_ids, 'b s ... -> (b s) ...')
+                input_ids = input_ids[word_idx]
+                input_ids = input_ids.unsqueeze(0)
+                labels = labels.view(-1)[word_idx]
+                labels = labels.unsqueeze(0)
+                loss_mask[labels == 1] = 0
+                total_s = cu_seqlen[-1].item()
+                shift_labels = preprocess_labels(labels.squeeze(), cu_seqlen)
+                shift_labels.requires_grad = False
+
+                layer.set_input_ctx((cu_seqlen, total_s))
+                #res = layer.forward(input_id, cu_seqlen, total_s)
+                res = layer.forward(input_ids)
+                loss_arr = vocab_parallel_cross_entropy(res.float(), shift_labels).transpose(0, 1).contiguous()
+                loss_mask = loss_mask.view(-1).float().to(loss_arr.device)
+                loss_mean = torch.sum(loss_arr.view(-1) * loss_mask) / loss_mask.sum().clamp(min=1)
+                losses.append(loss_mean.detach().clone())
+                loss = loss_mean / (gbs)
+                loss.backward()
+                #sample_check_pow2_grad(dict(layer.named_parameters()))
+            loss_report = sum(losses) / len(losses)
+            gather_objs = collect_scalars_across_data_parallel_group([loss_report], rank_generator.get_dp_group())
+            gathered_loss = sum(gather_objs[0]) / dp_size
+            losses = []
+            seen_token = (total_step * seq_len * mbs * gbs * world_size) / 1024.0 / 1024.0 # In M
+            optimizers.step()
+            end_time = time.perf_counter()
+            if rank == 0 and total_step % 1 == 0:
+                caliberated_grad_norm = optimizers.grad_norm()
+                print(f"[Rank-{rank}] epoch step: {total_step} step_time: {(end_time - start_time):.6f} consumed: {seen_token}M tokens Loss: {gathered_loss} grad_norm: {caliberated_grad_norm} lr: {optimizers.get_last_lr()[0]:.3e}")
+                db_logger.log_step({'training/loss': gathered_loss})
+            total_step += 1
+
+            if dump_dataloader_step is not None and total_step == dump_dataloader_step:
+                res = train_dataloader.__getstate__()
+                break
+
+            if enable_profiler:
+                if total_step == profiler_end_step:
+                    print("Ending profiler")
+                    prof.stop()
+                if total_step < profiler_end_step:
+                    prof.step()
+
+    train_dataloader.terminate()
+
+    train_dataloader_2 = build_dense_dataloader_only(
+        rank_generator, local_rank=local_rank,
+        epoch_number=epoch,
+        train_path='hdfs://harunava/home/byte_tteng_llm/data/final_datasets/thoth_v3.5_8T_1127_mix34/a6dac3f1/train',
+        val_path='hdfs://harunava/home/byte_tteng_llm/data/final_datasets/thoth_v2_2T_0427_with_domain/032e19a9/val',
+        train_size=1000000000000, val_size=-1, warmup_step_rate=0.005,
+        tokenizer_path='hdfs://harunava/home/byte_tteng_llm/user/thoth/tokenizer/bbpe-136k-ml-1227', pad_idx=1,
+        global_batch_size=gbs, micro_batch_size=1,
+        max_seqlen=seq_len, max_position_embeddings=max_position_embeddings, stride=stride,
+        lr_max=5e-4, lr_min=5e-5, weight_decay=0.1,
+        dp_size=dp_size, pp_size=pp_size, 
+        layer_number=layer_number, vocab_size=vocab_size, hidden_size=hidden_size, num_attention_head=num_attention_head, inner=inner,
+        is_deterministic=True,
+        #ckpt_callback=moe_dualpipe_ckpt_loading(layer_number, vocab_size, hidden_size, expert_num, expert_size, local_experts, dtype, device),
+    )
+
+    train_dataloader_2.__setstate__(res)
+    train_dataloader_iter_2 = iter(train_dataloader_2)
+
+    with prof:
+        for i in range(train_dataloader.length - total_step):
+        #for batches in train_dataloader_iter:
+            batches = next(train_dataloader_2)
+            start_time = time.perf_counter()
+            for batch in batches:
+                input_ids = batch['input_ids'].to(device=device)
+                cu_seqlen = batch['host_seqlens'].to(device=device)
+                word_idx = batch['word_idx'].to(device=device)
+                labels = batch['labels'].to(device=device)            
+                loss_mask = batch['rmpad_loss_mask'].to(device=device)
+                input_ids = rearrange(input_ids, 'b s ... -> (b s) ...')
+                input_ids = input_ids[word_idx]
+                input_ids = input_ids.unsqueeze(0)
+                labels = labels.view(-1)[word_idx]
+                labels = labels.unsqueeze(0)
+                loss_mask[labels == 1] = 0
+                total_s = cu_seqlen[-1].item()
+                shift_labels = preprocess_labels(labels.squeeze(), cu_seqlen)
+                shift_labels.requires_grad = False
+
+                layer.set_input_ctx((cu_seqlen, total_s))
+                #res = layer.forward(input_id, cu_seqlen, total_s)
+                res = layer.forward(input_ids)
+                loss_arr = vocab_parallel_cross_entropy(res.float(), shift_labels).transpose(0, 1).contiguous()
+                loss_mask = loss_mask.view(-1).float().to(loss_arr.device)
+                loss_mean = torch.sum(loss_arr.view(-1) * loss_mask) / loss_mask.sum().clamp(min=1)
+                losses.append(loss_mean.detach().clone())
+                loss = loss_mean / (gbs)
+                loss.backward()
+                #sample_check_pow2_grad(dict(layer.named_parameters()))
+            loss_report = sum(losses) / len(losses)
+            gather_objs = collect_scalars_across_data_parallel_group([loss_report], rank_generator.get_dp_group())
+            gathered_loss = sum(gather_objs[0]) / dp_size
+            losses = []
+            seen_token = (total_step * seq_len * mbs * gbs * world_size) / 1024.0 / 1024.0 # In M
+            optimizers.step()
+            end_time = time.perf_counter()
+            if rank == 0 and total_step % 1 == 0:
+                caliberated_grad_norm = optimizers.grad_norm()
+                print(f"[Rank-{rank}] epoch step: {total_step} step_time: {(end_time - start_time):.6f} consumed: {seen_token}M tokens Loss: {gathered_loss} grad_norm: {caliberated_grad_norm} lr: {optimizers.get_last_lr()[0]:.3e}")
+                db_logger.log_step({'training/loss': gathered_loss})
+            total_step += 1
+
+            if enable_profiler:
+                if total_step == profiler_end_step:
+                    print("Ending profiler")
+                    prof.stop()
+                if total_step < profiler_end_step:
+                    prof.step()
+
+    print("All done")
+
+def test_cross_node(ngpus):
+    torch.multiprocessing.spawn(do_main, args=(ngpus,), nprocs=ngpus, daemon=True)
+
+def main():
+    do_main()
+
+if __name__ == "__main__":
+    rank = int(os.environ['RANK'])
+    local_rank = int(os.environ['LOCAL_RANK'])
+    world_size = int(os.environ['WORLD_SIZE'])
+    print(f"[INIT] rank: {rank} local_rank: {local_rank} world_size: {world_size}")
+    do_main(rank, local_rank, world_size)

playground/Abbie-h100/torchrun/torchrun_dualpipe_moe_v.py

@@ -0,0 +1,196 @@
+import math
+import os
+import time
+from contextlib import nullcontext
+from typing import Optional
+
+import torch
+import torch.distributed as dist
+from einops import rearrange
+
+from dualpipe.module.shared.loss import criterion
+from dualpipe.log import WandbLogger
+from dualpipe.module.trainer_builder import build_moe_trainer, build_moe_dataloader_only
+
+#set_deterministic(42,False)
+_DEFAULT_LOCAL_DIR = '/opt/tiger/Abbie/profiles'
+
+TOKENIZER_PATH = '/opt/tiger/tokenizer/bbpe-136k-ml-1227'
+
+INITIALIZE_RANGE = 0.013975424859373685
+
+def make_handler(rank, local_dir):
+    def handler_fn(p):
+        # export trace data when traces ready (schedule cycle ends)
+        fname = "profileStep" + str(p.step_num) + "_globalStep" + str(0) + "_rank" + str(rank) + "." + \
+            str(int(time.time())) + ".pt.trace.json.gz"
+        local_file = os.path.join(local_dir, fname)
+        if not os.path.exists(local_dir):
+            print("mkdir ", local_dir)
+            os.makedirs(local_dir)
+        print("Save profile results to {}".format(local_file))
+        p.export_chrome_trace(local_file)
+        print("Local profile file saved")
+    return handler_fn
+
+
+def collect_scalars_across_data_parallel_group(scalars, dp_group):
+    """Reduce a tensor of losses across all GPUs."""
+    scalars = torch.cat(
+        [loss.clone().detach().view(1) for loss in scalars])
+    group_size = torch.distributed.get_world_size(group=dp_group)
+    out_scalars = [torch.ones_like(scalars) for i in range(group_size)]
+    torch.distributed.all_gather(out_scalars, scalars,
+                                 group=dp_group)
+    return out_scalars, group_size
+
+def main(rank, local_rank, ngpus, expert_num: int = 32, ep_size: int = 4, pp_size: int = 2, expert_size: int = 2752, top_k=4,
+         vocab_size: int = 136064, hidden_size: int = 2048, max_position_embeddings: int = 4096, stride: int=3840,
+         num_attention_head: int = 16, micro_batch_size: int=1, num_chunks: int=32, layer_number: int=24, seq_len: int = 4096,
+         resume_ckpt_path: Optional[str] = None,
+         enable_profiler: bool = False, profiler_step: int = 20, mem_profile_enable: bool= True, dump_dataloader_step: Optional[int] = None):
+    epoch = 1
+    mbs = 1
+    dp_size = ngpus // pp_size
+    torch.cuda.set_device(local_rank)
+    #torch.manual_seed(42)
+
+    dist.init_process_group(backend='nccl', init_method="env://", world_size=ngpus, rank=rank)
+    os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8"
+    device = f'cuda:{rank}'
+    dtype = torch.bfloat16
+    
+    db_logger = WandbLogger(rank, None, 'abbie_moe_1T_gbs128_dualpipe_ckpt_UT1_baseline')
+
+    # Communication group 
+    group = dist.distributed_c10d._get_default_group()
+    world_size = group.size()
+    # real gbs is divided by dq_size
+    gbs = 128 // dp_size
+    if mem_profile_enable:
+        torch.cuda.memory._record_memory_history()
+
+    rank_generator, dualpipev_model, train_dataloader, optimizers = build_moe_trainer(
+            rank=rank, local_rank=local_rank, world_size=world_size,
+            epoch_number=epoch,
+            train_path='hdfs://harunava/home/byte_tteng_llm/data/final_datasets/thoth_v3.5_8T_1127_mix34/a6dac3f1/train',
+            val_path='hdfs://harunava/home/byte_tteng_llm/data/final_datasets/thoth_v2_2T_0427_with_domain/032e19a9/val',
+            train_size=1000000000000, val_size=-1, warmup_step_rate=0.005,
+            tokenizer_path='hdfs://harunava/home/byte_tteng_llm/user/thoth/tokenizer/bbpe-136k-ml-1227', pad_idx=1,
+            global_batch_size=gbs, micro_batch_size=1,
+            max_seqlen=seq_len, max_position_embeddings=max_position_embeddings, stride=stride,
+            lr_max=5e-4, lr_min=5e-5, weight_decay=0.1,
+            dp_size=dp_size, pp_size=pp_size, ep_size=ep_size,
+            layer_number=layer_number, vocab_size=vocab_size, hidden_size=hidden_size,
+            num_attention_head=num_attention_head,
+            expert_size=expert_size, expert_num=expert_num, top_k=top_k,
+            is_deterministic=False,
+            #ckpt_callback=moe_dualpipe_ckpt_loading(layer_number, vocab_size, hidden_size, expert_num, expert_size, local_experts, dtype, device),
+    )
+
+    #optim, scheduler = build_optimizer_and_scheduler(rank, ddp_module)
+    print(f'[Rank-{rank}] INFO pp_rank: {rank_generator.get_pp_rank()} dp_rank: {rank_generator.get_dp_rank()} ep_rank: {rank_generator.get_ep_rank()}')
+    if rank_generator.is_first_rank():
+        print(f"[Rank-{rank}] I am the first rank among {ngpus=}, {expert_num=}, {ep_size=}, {hidden_size=}, {num_attention_head=}", flush=True)
+
+    total_step = 0
+    profiler_end_step = profiler_step + 10
+    if enable_profiler > 0:
+        prof = torch.profiler.profile(
+                            schedule=torch.profiler.schedule(wait=profiler_step, warmup=2, active=1, repeat=0),
+                            on_trace_ready=make_handler(rank, _DEFAULT_LOCAL_DIR),
+                            record_shapes=True,
+                            profile_memory=True,
+                            with_modules=True,
+                            with_stack=int(torch.__version__[0])>=2)
+    else:
+        prof = nullcontext()
+    
+    train_dataloader_iter = iter(train_dataloader)
+    with prof:
+        for batches in train_dataloader_iter:
+            losses = []
+            input_ids_arr = []
+            cu_seqlens_arr = []
+            inp_shapes_arr = []
+            total_ses_arr = []
+            labels_arr = []
+            loss_mask_arr = []
+            for b in batches:
+                # Commonly used by input_ids and labels.
+                word_idx = b['word_idx'].to(device=device)
+
+                # process input_ids
+                input_ids = b['input_ids'].to(device=device)
+                input_ids = rearrange(input_ids, 'b s ... -> (b s) ...')
+                input_ids = input_ids[word_idx]
+                input_ids = input_ids.unsqueeze(0)
+                input_ids_arr.append(input_ids)# Appending 
+
+                # process cu_seqlens & total_s
+                cu_seqlens = b['host_seqlens'].to(device=device)
+                cu_seqlens_arr.append(cu_seqlens)
+                total_s = cu_seqlens[-1].item()
+                total_ses_arr.append(total_s)
+
+                # process labels
+                labels = b['labels'].to(device=device)            
+                labels = labels.view(-1)[word_idx]
+                labels = labels.unsqueeze(0)
+                labels_arr.append(labels)
+
+                # process loss_mask
+                loss_mask = b['rmpad_loss_mask'].to(device=device)
+                loss_mask[labels == 1] = 0
+                loss_mask_arr.append(loss_mask)
+
+                # input shapes.
+                inp_shape = (total_s, micro_batch_size, hidden_size)
+                inp_shapes_arr.append(inp_shape)
+
+            if not rank_generator.is_first_rank():
+                hidden_states = [None for _ in range(num_chunks)]
+            else:
+                hidden_states = input_ids_arr
+            input_ctx = [(c, t, gbs) for c, t in zip(cu_seqlens_arr, total_ses_arr)]
+            start_time = time.perf_counter()
+            loss, outputs = dualpipev_model.step(hidden_states, input_shapes=inp_shapes_arr, input_ctx=input_ctx, num_chunks=num_chunks, criterion=criterion, labels=labels_arr, return_outputs=False)
+            end_time = time.perf_counter()
+            if rank_generator.is_first_rank():
+                losses.append(loss)
+                #res = layer.forward(input_ids)
+                #sample_check_pow2_grad(dict(layer.named_parameters()))
+            if rank_generator.get_pp_rank() == 0:
+                losses = torch.cat(losses) * gbs
+                loss_report = sum(losses) / len(losses)
+                gather_objs = collect_scalars_across_data_parallel_group([loss_report], rank_generator.get_dp_group())
+                gathered_loss = sum(gather_objs[0]) / dp_size
+            seen_token = (total_step * seq_len * mbs * gbs * ngpus) / 1024.0 / 1024.0 # In M
+            optimizers.step()
+            #dense_optim.step()
+            #moe_optim.step()
+            if rank == 0 and total_step % 1 == 0:
+                #caliberated_grad_norm = math.sqrt(dense_optim.grad_norm**2 + moe_optim.grad_norm**2)
+                caliberated_grad_norm = optimizers.grad_norm()
+                print(f"[Rank-{rank}] epoch step: {total_step} step_time: {(end_time - start_time):.6f} consumed: {seen_token}M tokens Loss: {gathered_loss} grad_norm: {caliberated_grad_norm} lr: {optimizers.get_last_lr()[0]:.3e}")
+                db_logger.log_step({'training/loss': gathered_loss})
+            total_step += 1
+            if dump_dataloader_step is not None and total_step == dump_dataloader_step:
+                res = train_dataloader.__getstate__()
+                break
+            if enable_profiler:
+                if total_step == profiler_end_step:
+                    print("Ending profiler")
+                    prof.stop()
+                if total_step < profiler_end_step:
+                    prof.step()
+
+    train_dataloader.terminate()
+    print(f"[{rank}] {loss}")
+
+
+if __name__ == "__main__":
+    rank = int(os.environ['RANK'])
+    local_rank = int(os.environ['LOCAL_RANK'])
+    world_size = int(os.environ['WORLD_SIZE'])
+    main(rank, local_rank, world_size)

playground/Abbie-h100/torchrun/torchrun_dualpipe_moe_v_ckpt.py

@@ -0,0 +1,310 @@
+import math
+import os
+import time
+from contextlib import nullcontext
+from typing import Optional
+
+import torch
+import torch.distributed as dist
+from einops import rearrange
+
+from transformers import AutoTokenizer
+from dualpipe.module.shared.loss import criterion
+from dualpipe.module.config import GargantuaConfig, OptimizerConfig
+from dualpipe.module.gargantua.transformer_layer import TransformerGargantuaLayer
+from dualpipe.module.parallel_states import build_rank_generator, get_dist_env, DistEnv, RankGenerator
+from dualpipe.module.shared.vocab import initialize_kernel
+from dualpipe.module.shared.optimizer import MixPrecisionDDPOptimizer
+from dualpipe.communicator import Communicator
+from dualpipe import DualPipeTrainMoeV
+from dualpipe.deterministic import set_deterministic
+from dualpipe.log import WandbLogger
+from dataloader.config import TrainerConfig
+from dataloader.unsupervised import SaharaDatamodule
+from dualpipe.module.trainer_builder import build_moe_trainer, build_moe_dataloader_only
+
+#set_deterministic(42,False)
+_DEFAULT_LOCAL_DIR = '/opt/tiger/Abbie/profiles'
+
+TOKENIZER_PATH = '/opt/tiger/tokenizer/bbpe-136k-ml-1227'
+
+INITIALIZE_RANGE = 0.013975424859373685
+
+def make_handler(rank, local_dir):
+    def handler_fn(p):
+        # export trace data when traces ready (schedule cycle ends)
+        fname = "profileStep" + str(p.step_num) + "_globalStep" + str(0) + "_rank" + str(rank) + "." + \
+            str(int(time.time())) + ".pt.trace.json.gz"
+        local_file = os.path.join(local_dir, fname)
+        if not os.path.exists(local_dir):
+            print("mkdir ", local_dir)
+            os.makedirs(local_dir)
+        print("Save profile results to {}".format(local_file))
+        p.export_chrome_trace(local_file)
+        print("Local profile file saved")
+    return handler_fn
+
+
+def collect_scalars_across_data_parallel_group(scalars, dp_group):
+    """Reduce a tensor of losses across all GPUs."""
+    scalars = torch.cat(
+        [loss.clone().detach().view(1) for loss in scalars])
+    group_size = torch.distributed.get_world_size(group=dp_group)
+    out_scalars = [torch.ones_like(scalars) for i in range(group_size)]
+    torch.distributed.all_gather(out_scalars, scalars,
+                                 group=dp_group)
+    return out_scalars, group_size
+
+def main(rank, local_rank, ngpus, expert_num: int = 32, ep_size: int = 4, pp_size: int = 2, expert_size: int = 2752, top_k=4,
+         vocab_size: int = 136064, hidden_size: int = 2048, max_position_embeddings: int = 4096, stride: int=3840,
+         num_attention_head: int = 16, micro_batch_size: int=1, num_chunks: int=32, layer_number: int=24, seq_len: int = 4096,
+         resume_ckpt_path: Optional[str] = None,
+         enable_profiler: bool = False, profiler_step: int = 20, mem_profile_enable: bool= True, dump_dataloader_step: int= 10):
+    epoch = 1
+    mbs = 1
+    dp_size = ngpus // pp_size
+    torch.cuda.set_device(rank)
+    local_experts = (expert_num // ep_size)
+    torch.manual_seed(42)
+    dist.init_process_group(backend='nccl', init_method="env://", world_size=ngpus, rank=rank)
+    initialize_kernel()
+    os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8"
+    device = f'cuda:{rank}'
+    dtype = torch.bfloat16
+    
+    db_logger = WandbLogger(rank, None, 'abbie_moe_1T_gbs128_dualpipe_ckpt_UT1_baseline')
+
+    # Communication group 
+    group = dist.distributed_c10d._get_default_group()
+    world_size = group.size()
+    # real gbs is divided by dq_size
+    gbs = 128 // dp_size
+    if mem_profile_enable:
+        torch.cuda.memory._record_memory_history()
+
+    rank_generator, dualpipev_model, train_dataloader, optimizers = build_moe_trainer(
+            rank=rank, local_rank=local_rank, world_size=world_size,
+            epoch_number=epoch,
+            train_path='hdfs://harunava/home/byte_tteng_llm/data/final_datasets/thoth_v3.5_8T_1127_mix34/a6dac3f1/train',
+            val_path='hdfs://harunava/home/byte_tteng_llm/data/final_datasets/thoth_v2_2T_0427_with_domain/032e19a9/val',
+            train_size=1000000000000, val_size=-1, warmup_step_rate=0.005,
+            tokenizer_path='hdfs://harunava/home/byte_tteng_llm/user/thoth/tokenizer/bbpe-136k-ml-1227', pad_idx=1,
+            global_batch_size=gbs, micro_batch_size=1,
+            max_seqlen=seq_len, max_position_embeddings=max_position_embeddings, stride=stride,
+            lr_max=5e-4, lr_min=5e-5, weight_decay=0.1,
+            dp_size=dp_size, pp_size=pp_size, ep_size=ep_size,
+            layer_number=layer_number, vocab_size=vocab_size, hidden_size=hidden_size,
+            num_attention_head=num_attention_head,
+            expert_size=expert_size, expert_num=expert_num, top_k=top_k,
+            is_deterministic=False,
+            #ckpt_callback=moe_dualpipe_ckpt_loading(layer_number, vocab_size, hidden_size, expert_num, expert_size, local_experts, dtype, device),
+    )
+
+    #optim, scheduler = build_optimizer_and_scheduler(rank, ddp_module)
+    print(f'[Rank-{rank}] INFO pp_rank: {rank_generator.get_pp_rank()} dp_rank: {rank_generator.get_dp_rank()} ep_rank: {rank_generator.get_ep_rank()}')
+    if rank_generator.is_first_rank():
+        print(f"[Rank-{rank}] I am the first rank among {ngpus=}, {expert_num=}, {ep_size=}, {hidden_size=}, {num_attention_head=}", flush=True)
+
+    total_step = 0
+    profiler_end_step = profiler_step + 10
+    if enable_profiler > 0:
+        prof = torch.profiler.profile(
+                            schedule=torch.profiler.schedule(wait=profiler_step, warmup=2, active=1, repeat=0),
+                            on_trace_ready=make_handler(rank, _DEFAULT_LOCAL_DIR),
+                            record_shapes=True,
+                            profile_memory=True,
+                            with_modules=True,
+                            with_stack=int(torch.__version__[0])>=2)
+    else:
+        prof = nullcontext()
+    
+    train_dataloader_iter = iter(train_dataloader)
+    with prof:
+        for batches in train_dataloader_iter:
+            losses = []
+            input_ids_arr = []
+            cu_seqlens_arr = []
+            inp_shapes_arr = []
+            total_ses_arr = []
+            labels_arr = []
+            loss_mask_arr = []
+            for b in batches:            
+                # Commonly used by input_ids and labels.
+                word_idx = b['word_idx'].to(device=device)
+
+                # process input_ids
+                input_ids = b['input_ids'].to(device=device)
+                input_ids = rearrange(input_ids, 'b s ... -> (b s) ...')
+                input_ids = input_ids[word_idx]
+                input_ids = input_ids.unsqueeze(0)
+                input_ids_arr.append(input_ids)# Appending 
+
+                # process cu_seqlens & total_s
+                cu_seqlens = b['host_seqlens'].to(device=device)
+                cu_seqlens_arr.append(cu_seqlens)
+                total_s = cu_seqlens[-1].item()
+                total_ses_arr.append(total_s)
+
+                # process labels
+                labels = b['labels'].to(device=device)            
+                labels = labels.view(-1)[word_idx]
+                labels = labels.unsqueeze(0)
+                labels_arr.append(labels)
+
+                # process loss_mask
+                loss_mask = b['rmpad_loss_mask'].to(device=device)
+                loss_mask[labels == 1] = 0
+                loss_mask_arr.append(loss_mask)
+
+                # input shapes.
+                inp_shape = (total_s, micro_batch_size, hidden_size)
+                inp_shapes_arr.append(inp_shape)
+
+            if not rank_generator.is_first_rank():
+                hidden_states = [None for _ in range(num_chunks)]
+            else:
+                hidden_states = input_ids_arr
+            input_ctx = [(c, t, gbs) for c, t in zip(cu_seqlens_arr, total_ses_arr)]
+            start_time = time.perf_counter()
+            loss, outputs = dualpipev_model.step(hidden_states, input_shapes=inp_shapes_arr, input_ctx=input_ctx, num_chunks=num_chunks, criterion=criterion, labels=labels_arr, return_outputs=False)
+            end_time = time.perf_counter()
+            if rank_generator.is_first_rank():
+                losses.append(loss)
+                #res = layer.forward(input_ids)
+                #sample_check_pow2_grad(dict(layer.named_parameters()))
+            if rank_generator.get_pp_rank() == 0:
+                losses = torch.cat(losses) * gbs
+                loss_report = sum(losses) / len(losses)
+                gather_objs = collect_scalars_across_data_parallel_group([loss_report], rank_generator.get_dp_group())
+                gathered_loss = sum(gather_objs[0]) / dp_size
+            seen_token = (total_step * seq_len * mbs * gbs * ngpus) / 1024.0 / 1024.0 # In M
+            optimizers.step()
+            #dense_optim.step()
+            #moe_optim.step()
+            if rank == 0 and total_step % 1 == 0:
+                #caliberated_grad_norm = math.sqrt(dense_optim.grad_norm**2 + moe_optim.grad_norm**2)
+                caliberated_grad_norm = optimizers.grad_norm()
+                print(f"[Rank-{rank}] epoch step: {total_step} step_time: {(end_time - start_time):.6f} consumed: {seen_token}M tokens Loss: {gathered_loss} grad_norm: {caliberated_grad_norm} lr: {optimizers.get_last_lr()[0]:.3e}")
+                db_logger.log_step({'training/loss': gathered_loss})
+            total_step += 1
+            if total_step == dump_dataloader_step:
+                res = train_dataloader.__getstate__()
+                break
+            if enable_profiler:
+                if total_step == profiler_end_step:
+                    print("Ending profiler")
+                    prof.stop()
+                if total_step < profiler_end_step:
+                    prof.step()
+
+    train_dataloader.terminate()
+
+    train_dataloader_2 = build_moe_dataloader_only(
+            rank_generator, local_rank=local_rank,
+            epoch_number=epoch,
+            train_path='hdfs://harunava/home/byte_tteng_llm/data/final_datasets/thoth_v3.5_8T_1127_mix34/a6dac3f1/train',
+            val_path='hdfs://harunava/home/byte_tteng_llm/data/final_datasets/thoth_v2_2T_0427_with_domain/032e19a9/val',
+            train_size=1000000000000, val_size=-1, warmup_step_rate=0.005,
+            tokenizer_path='hdfs://harunava/home/byte_tteng_llm/user/thoth/tokenizer/bbpe-136k-ml-1227', pad_idx=1,
+            global_batch_size=gbs, micro_batch_size=1,
+            max_seqlen=seq_len, max_position_embeddings=max_position_embeddings, stride=stride,
+            lr_max=5e-4, lr_min=5e-5, weight_decay=0.1,
+            dp_size=dp_size, pp_size=pp_size, ep_size=ep_size,
+            layer_number=layer_number, vocab_size=vocab_size, hidden_size=hidden_size,
+            num_attention_head=num_attention_head,
+            expert_size=expert_size, expert_num=expert_num, top_k=top_k,
+            is_deterministic=False,
+            #ckpt_callback=moe_dualpipe_ckpt_loading(layer_number, vocab_size, hidden_size, expert_num, expert_size, local_experts, dtype, device),
+    )
+
+    train_dataloader_2.__setstate__(res)
+    train_dataloader_iter2 = iter(train_dataloader_2)
+    with prof:
+        for batches in train_dataloader_iter2:
+            losses = []
+            input_ids_arr = []
+            cu_seqlens_arr = []
+            inp_shapes_arr = []
+            total_ses_arr = []
+            labels_arr = []
+            loss_mask_arr = []
+            for b in batches:            
+                # Commonly used by input_ids and labels.
+                word_idx = b['word_idx'].to(device=device)
+
+                # process input_ids
+                input_ids = b['input_ids'].to(device=device)
+                input_ids = rearrange(input_ids, 'b s ... -> (b s) ...')
+                input_ids = input_ids[word_idx]
+                input_ids = input_ids.unsqueeze(0)
+                input_ids_arr.append(input_ids)# Appending 
+
+                # process cu_seqlens & total_s
+                cu_seqlens = b['host_seqlens'].to(device=device)
+                cu_seqlens_arr.append(cu_seqlens)
+                total_s = cu_seqlens[-1].item()
+                total_ses_arr.append(total_s)
+
+                # process labels
+                labels = b['labels'].to(device=device)            
+                labels = labels.view(-1)[word_idx]
+                labels = labels.unsqueeze(0)
+                labels_arr.append(labels)
+
+                # process loss_mask
+                loss_mask = b['rmpad_loss_mask'].to(device=device)
+                loss_mask[labels == 1] = 0
+                loss_mask_arr.append(loss_mask)
+
+                # input shapes.
+                inp_shape = (total_s, micro_batch_size, hidden_size)
+                inp_shapes_arr.append(inp_shape)
+
+            if not rank_generator.is_first_rank():
+                hidden_states = [None for _ in range(num_chunks)]
+            else:
+                hidden_states = input_ids_arr
+            input_ctx = [(c, t, gbs) for c, t in zip(cu_seqlens_arr, total_ses_arr)]
+            start_time = time.perf_counter()
+            loss, outputs = dualpipev_model.step(hidden_states, input_shapes=inp_shapes_arr, input_ctx=input_ctx, num_chunks=num_chunks, criterion=criterion, labels=labels_arr, return_outputs=False)
+            end_time = time.perf_counter()
+            if rank_generator.is_first_rank():
+                losses.append(loss)
+                #res = layer.forward(input_ids)
+                #sample_check_pow2_grad(dict(layer.named_parameters()))
+            if rank_generator.get_pp_rank() == 0:
+                losses = torch.cat(losses) * gbs
+                loss_report = sum(losses) / len(losses)
+                gather_objs = collect_scalars_across_data_parallel_group([loss_report], rank_generator.get_dp_group())
+                gathered_loss = sum(gather_objs[0]) / dp_size
+            seen_token = (total_step * seq_len * mbs * gbs * ngpus) / 1024.0 / 1024.0 # In M
+            optimizers.step()
+            #dense_optim.step()
+            #moe_optim.step()
+            if rank == 0 and total_step % 1 == 0:
+                #caliberated_grad_norm = math.sqrt(dense_optim.grad_norm**2 + moe_optim.grad_norm**2)
+                caliberated_grad_norm = optimizers.grad_norm()
+                print(f"[Rank-{rank}] epoch step: {total_step} step_time: {(end_time - start_time):.6f} consumed: {seen_token}M tokens Loss: {gathered_loss} grad_norm: {caliberated_grad_norm} lr: {optimizers.get_last_lr()[0]:.3e}")
+                db_logger.log_step({'training/loss': gathered_loss})
+            total_step += 1
+            if total_step == dump_dataloader_step:
+                res = train_dataloader.__getstate__()
+                train_dataloader.__setstate__(res)
+                break
+            if enable_profiler:
+                if total_step == profiler_end_step:
+                    print("Ending profiler")
+                    prof.stop()
+                if total_step < profiler_end_step:
+                    prof.step()
+
+
+
+    print(f"[{rank}] {loss}")
+
+
+if __name__ == "__main__":
+    rank = int(os.environ['RANK'])
+    local_rank = int(os.environ['LOCAL_RANK'])
+    world_size = int(os.environ['WORLD_SIZE'])
+    main(rank, local_rank, world_size)

playground/Abbie-h100/torchrun/torchrun_moe_gargantua.py

@@ -0,0 +1,151 @@
+import os
+
+import math
+import time
+from typing import Optional
+
+import torch
+import torch.distributed as dist
+
+from einops import rearrange
+from dualpipe.log import WandbLogger
+from dualpipe.deterministic import set_deterministic
+
+import numpy as np
+
+from dualpipe.module.shared.loss import preprocess_labels
+
+set_deterministic(42, False)
+
+from dualpipe.module.parallel_states import build_rank_generator, get_dist_env
+from dualpipe.module.config import GargantuaConfig, OptimizerConfig
+from dualpipe.module.gargantua.transformer_layer import TransformerGargantuaLayer
+from dualpipe.module.shared.vocab import vocab_parallel_cross_entropy
+from dualpipe.module.shared.optimizer import MixPrecisionDDPOptimizer
+
+from dataloader.config import TrainerConfig
+from dataloader.unsupervised import SaharaDatamodule
+
+from dualpipe.module.trainer_builder import build_moe_trainer, build_moe_dataloader_only
+
+
+RANDOM_INPUTS = os.environ.get("RANDOM_INPUTS", "0") == "1"
+TOKENIZER_PATH = '/opt/tiger/tokenizer/bbpe-136k-ml-1227'
+
+torch.manual_seed(42)
+np.random.seed(42)
+
+
+def collect_scalars_across_data_parallel_group(scalars, dp_group):
+    """Reduce a tensor of losses across all GPUs."""
+    scalars = torch.cat(
+        [loss.clone().detach().view(1) for loss in scalars])
+    group_size = torch.distributed.get_world_size(group=dp_group)
+    out_scalars = [torch.ones_like(scalars) for i in range(group_size)]
+    torch.distributed.all_gather(out_scalars, scalars,
+                                 group=dp_group)
+    return out_scalars, group_size
+
+def do_main(rank, local_rank, ngpus,
+            expert_num: int = 16, ep_size: int = 2, top_k=2, pp_size: int = 1,
+            vocab_size: int = 136064, expert_size: int = 640, hidden_size: int = 2048,
+            max_position_embeddings: int = 4096, stride=3840,
+            resume_ckpt_path: Optional[str] = None,
+            gbs: int = 128, num_attention_head: int = 16, layer_number: int = 12, seq_len:int = 4096, dump_dataloader_step: int= 2000):
+    epoch = 1
+    mbs = 1
+    gbs = gbs // ngpus
+    set_deterministic(42, False)
+    
+    assert ngpus % pp_size == 0
+    dp_size = ngpus // pp_size
+
+    local_experts = (expert_num // ep_size)
+    dist.init_process_group(backend='nccl', init_method="env://", world_size=ngpus, rank=rank)
+    #initialize_kernel()
+ 
+    device = f'cuda:{rank}'
+    dtype = torch.bfloat16    
+
+    db_logger = WandbLogger(rank, None, 'abbie_moe_1T_gbs128_gargantua_nopp_ckpt_UT1_b5_t2')
+    group = dist.distributed_c10d._get_default_group()
+    world_size = group.size()
+
+    rank_generator, layer, train_dataloader, optimizers = build_moe_trainer(
+        rank=rank, local_rank=local_rank, world_size=world_size,
+        epoch_number=epoch,
+        train_path='hdfs://harunava/home/byte_tteng_llm/data/final_datasets/thoth_v3.5_8T_1127_mix34/a6dac3f1/train',
+        val_path='hdfs://harunava/home/byte_tteng_llm/data/final_datasets/thoth_v2_2T_0427_with_domain/032e19a9/val',
+        train_size=1000000000000, val_size=-1, warmup_step_rate=0.005,
+        tokenizer_path='hdfs://harunava/home/byte_tteng_llm/user/thoth/tokenizer/bbpe-136k-ml-1227', pad_idx=1,
+        global_batch_size=gbs, micro_batch_size=1,
+        max_seqlen=seq_len, max_position_embeddings=max_position_embeddings, stride=stride,
+        lr_max=5e-4, lr_min=5e-5, weight_decay=0.1,
+        dp_size=dp_size, pp_size=pp_size, ep_size=ep_size,
+        layer_number=layer_number, vocab_size=vocab_size, hidden_size=hidden_size, num_attention_head=num_attention_head,
+        expert_size=expert_size, expert_num=expert_num, top_k=top_k,
+        is_deterministic=True,
+    )
+    
+    losses = []
+    total_step = 0
+    train_dataloader_iter = iter(train_dataloader)
+    for i in range(dump_dataloader_step):
+    #for batches in train_dataloader_iter:
+        batches = next(train_dataloader)
+        start_time = time.perf_counter()
+        for batch in batches:
+            input_ids = batch['input_ids'].to(device=device)
+            cu_seqlen = batch['host_seqlens'].to(device=device)
+            word_idx = batch['word_idx'].to(device=device)
+            labels = batch['labels'].to(device=device)            
+            loss_mask = batch['rmpad_loss_mask'].to(device=device)
+            input_ids = rearrange(input_ids, 'b s ... -> (b s) ...')
+            input_ids = input_ids[word_idx]
+            input_ids = input_ids.unsqueeze(0)
+            labels = labels.view(-1)[word_idx]
+            labels = labels.unsqueeze(0)
+            loss_mask[labels == 1] = 0
+            total_s = cu_seqlen[-1].item()
+            shift_labels = preprocess_labels(labels.squeeze(), cu_seqlen)
+            shift_labels.requires_grad = False
+
+            layer.set_input_ctx((cu_seqlen, total_s))
+            #res = layer.forward(input_id, cu_seqlen, total_s)
+            res = layer.forward(input_ids)
+            loss_arr = vocab_parallel_cross_entropy(res.float(), shift_labels).transpose(0, 1).contiguous()
+            loss_mask = loss_mask.view(-1).float().to(loss_arr.device)
+            loss_mean = torch.sum(loss_arr.view(-1) * loss_mask) / loss_mask.sum().clamp(min=1)
+            losses.append(loss_mean.detach().clone())
+            loss = loss_mean / (gbs)
+            loss.backward()
+            #sample_check_pow2_grad(dict(layer.named_parameters()))
+        loss_report = sum(losses) / len(losses)
+        gather_objs = collect_scalars_across_data_parallel_group([loss_report], rank_generator.get_dp_group())
+        gathered_loss = sum(gather_objs[0]) / dp_size
+        losses = []
+        seen_token = (total_step * seq_len * mbs * gbs * ngpus) / 1024.0 / 1024.0 # In M
+        optimizers.step()
+        end_time = time.perf_counter()
+        if rank == 0 and total_step % 1 == 0:
+            caliberated_grad_norm = optimizers.grad_norm()
+            print(f"[Rank-{rank}] epoch step: {total_step} step_time: {(end_time - start_time):.6f} consumed: {seen_token}M tokens Loss: {gathered_loss} grad_norm: {caliberated_grad_norm} lr: {optimizers.get_last_lr()[0]:.3e}")
+            db_logger.log_step({'training/loss': gathered_loss})
+        total_step += 1
+
+        if total_step == dump_dataloader_step:
+            res = train_dataloader.__getstate__()
+
+    print("All done")
+
+def test_cross_node(ngpus):
+    torch.multiprocessing.spawn(do_main, args=(ngpus,), nprocs=ngpus, daemon=True)
+
+def main():
+    do_main()
+
+if __name__ == "__main__":
+    rank = int(os.environ['RANK'])
+    local_rank = int(os.environ['LOCAL_RANK'])
+    world_size = int(os.environ['WORLD_SIZE'])
+    do_main(rank, local_rank, world_size)

playground/Abbie-h100/torchrun/torchrun_moe_gargantua_ckpt.py

@@ -0,0 +1,214 @@
+import os
+
+import math
+import time
+from typing import Optional
+
+import torch
+import torch.distributed as dist
+
+from einops import rearrange
+from dualpipe.log import WandbLogger
+from dualpipe.deterministic import set_deterministic
+
+import numpy as np
+
+from dualpipe.module.shared.loss import preprocess_labels
+
+set_deterministic(42, False)
+
+from dualpipe.module.parallel_states import build_rank_generator, get_dist_env
+from dualpipe.module.config import GargantuaConfig, OptimizerConfig
+from dualpipe.module.gargantua.transformer_layer import TransformerGargantuaLayer
+from dualpipe.module.shared.vocab import vocab_parallel_cross_entropy
+from dualpipe.module.shared.optimizer import MixPrecisionDDPOptimizer
+
+from dataloader.config import TrainerConfig
+from dataloader.unsupervised import SaharaDatamodule
+
+from dualpipe.module.trainer_builder import build_moe_trainer, build_moe_dataloader_only
+
+RANDOM_INPUTS = os.environ.get("RANDOM_INPUTS", "0") == "1"
+TOKENIZER_PATH = '/opt/tiger/tokenizer/bbpe-136k-ml-1227'
+
+torch.manual_seed(42)
+np.random.seed(42)
+
+
+def collect_scalars_across_data_parallel_group(scalars, dp_group):
+    """Reduce a tensor of losses across all GPUs."""
+    scalars = torch.cat(
+        [loss.clone().detach().view(1) for loss in scalars])
+    group_size = torch.distributed.get_world_size(group=dp_group)
+    out_scalars = [torch.ones_like(scalars) for i in range(group_size)]
+    torch.distributed.all_gather(out_scalars, scalars,
+                                 group=dp_group)
+    return out_scalars, group_size
+
+def do_main(rank, local_rank, ngpus,
+            expert_num: int = 16, dp_size: int= 2, ep_size: int = 2, top_k=2, pp_size: int = 1,
+            vocab_size: int = 136064, expert_size: int = 640, hidden_size: int = 2048,
+            max_position_embeddings: int = 4096, stride=3840,
+            resume_ckpt_path: Optional[str] = None,
+            gbs: int = 128, num_attention_head: int = 16, layer_number: int = 12, seq_len:int = 4096, dump_dataloader_step: int= 2000):
+    epoch = 1
+    mbs = 1
+    gbs = gbs // ngpus
+    set_deterministic(42, False)
+    
+    local_experts = (expert_num // ep_size)
+    dist.init_process_group(backend='nccl', init_method="env://", world_size=ngpus, rank=rank)
+ 
+    device = f'cuda:{rank}'
+    dtype = torch.bfloat16    
+
+    db_logger = WandbLogger(rank, None, 'abbie_moe_1T_gbs128_gargantua_nopp_ckpt_UT1_b5_t2')
+    group = dist.distributed_c10d._get_default_group()
+    world_size = group.size()
+
+    rank_generator, layer, train_dataloader, optimizers = build_moe_trainer(
+        rank=rank, local_rank=local_rank, world_size=world_size,
+        epoch_number=epoch,
+        train_path='hdfs://harunava/home/byte_tteng_llm/data/final_datasets/thoth_v3.5_8T_1127_mix34/a6dac3f1/train',
+        val_path='hdfs://harunava/home/byte_tteng_llm/data/final_datasets/thoth_v2_2T_0427_with_domain/032e19a9/val',
+        train_size=1000000000000, val_size=-1, warmup_step_rate=0.005,
+        tokenizer_path='hdfs://harunava/home/byte_tteng_llm/user/thoth/tokenizer/bbpe-136k-ml-1227', pad_idx=1,
+        global_batch_size=gbs, micro_batch_size=1,
+        max_seqlen=seq_len, max_position_embeddings=max_position_embeddings, stride=stride,
+        lr_max=5e-4, lr_min=5e-5, weight_decay=0.1,
+        dp_size=dp_size, pp_size=pp_size, ep_size=ep_size,
+        layer_number=layer_number, vocab_size=vocab_size, hidden_size=hidden_size, num_attention_head=num_attention_head,
+        expert_size=expert_size, expert_num=expert_num, top_k=top_k,
+        is_deterministic=True,
+        #ckpt_callback=moe_nopipe_ckpt_loading(layer_number, vocab_size, hidden_size, expert_num, expert_size, local_experts, dtype, device),
+    )
+    
+    losses = []
+    total_step = 0
+    train_dataloader_iter = iter(train_dataloader)
+    for i in range(dump_dataloader_step):
+    #for batches in train_dataloader_iter:
+        batches = next(train_dataloader)
+        start_time = time.perf_counter()
+        for batch in batches:
+            input_ids = batch['input_ids'].to(device=device)
+            cu_seqlen = batch['host_seqlens'].to(device=device)
+            word_idx = batch['word_idx'].to(device=device)
+            labels = batch['labels'].to(device=device)            
+            loss_mask = batch['rmpad_loss_mask'].to(device=device)
+            input_ids = rearrange(input_ids, 'b s ... -> (b s) ...')
+            input_ids = input_ids[word_idx]
+            input_ids = input_ids.unsqueeze(0)
+            labels = labels.view(-1)[word_idx]
+            labels = labels.unsqueeze(0)
+            loss_mask[labels == 1] = 0
+            total_s = cu_seqlen[-1].item()
+            shift_labels = preprocess_labels(labels.squeeze(), cu_seqlen)
+            shift_labels.requires_grad = False
+
+            layer.set_input_ctx((cu_seqlen, total_s))
+            #res = layer.forward(input_id, cu_seqlen, total_s)
+            res = layer.forward(input_ids)
+            loss_arr = vocab_parallel_cross_entropy(res.float(), shift_labels).transpose(0, 1).contiguous()
+            loss_mask = loss_mask.view(-1).float().to(loss_arr.device)
+            loss_mean = torch.sum(loss_arr.view(-1) * loss_mask) / loss_mask.sum().clamp(min=1)
+            losses.append(loss_mean.detach().clone())
+            loss = loss_mean / (gbs)
+            loss.backward()
+            #sample_check_pow2_grad(dict(layer.named_parameters()))
+        loss_report = sum(losses) / len(losses)
+        gather_objs = collect_scalars_across_data_parallel_group([loss_report], rank_generator.get_dp_group())
+        gathered_loss = sum(gather_objs[0]) / dp_size
+        losses = []
+        seen_token = (total_step * seq_len * mbs * gbs * ngpus) / 1024.0 / 1024.0 # In M
+        optimizers.step()
+        end_time = time.perf_counter()
+        if rank == 0 and total_step % 1 == 0:
+            caliberated_grad_norm = optimizers.grad_norm()
+            print(f"[Rank-{rank}] epoch step: {total_step} step_time: {(end_time - start_time):.6f} consumed: {seen_token}M tokens Loss: {gathered_loss} grad_norm: {caliberated_grad_norm} lr: {optimizers.get_last_lr()[0]:.3e}")
+            db_logger.log_step({'training/loss': gathered_loss})
+        total_step += 1
+
+        if total_step == dump_dataloader_step:
+            res = train_dataloader.__getstate__()
+
+    train_dataloader.terminate()
+
+    train_dataloader_2 = build_moe_dataloader_only(
+            rank_generator, local_rank=local_rank,
+            epoch_number=epoch,
+            train_path='hdfs://harunava/home/byte_tteng_llm/data/final_datasets/thoth_v3.5_8T_1127_mix34/a6dac3f1/train',
+            val_path='hdfs://harunava/home/byte_tteng_llm/data/final_datasets/thoth_v2_2T_0427_with_domain/032e19a9/val',
+            train_size=1000000000000, val_size=-1, warmup_step_rate=0.005,
+            tokenizer_path='hdfs://harunava/home/byte_tteng_llm/user/thoth/tokenizer/bbpe-136k-ml-1227', pad_idx=1,
+            global_batch_size=gbs, micro_batch_size=1,
+            max_seqlen=seq_len, max_position_embeddings=max_position_embeddings, stride=stride,
+            lr_max=5e-4, lr_min=5e-5, weight_decay=0.1,
+            dp_size=dp_size, pp_size=pp_size, ep_size=ep_size,
+            layer_number=layer_number, vocab_size=vocab_size, hidden_size=hidden_size,
+            num_attention_head=num_attention_head,
+            expert_size=expert_size, expert_num=expert_num, top_k=top_k,
+            is_deterministic=False,
+            #ckpt_callback=moe_dualpipe_ckpt_loading(layer_number, vocab_size, hidden_size, expert_num, expert_size, local_experts, dtype, device),
+    )
+
+    train_dataloader_2.__setstate__(res)
+    train_dataloader_iter_2 = iter(train_dataloader_2)
+    
+    for i in range(200000):
+    #for batches in train_dataloader_iter_2:
+        batches = next(train_dataloader_2)
+        start_time = time.perf_counter()
+        for batch in batches:
+            input_ids = batch['input_ids'].to(device=device)
+            cu_seqlen = batch['host_seqlens'].to(device=device)
+            word_idx = batch['word_idx'].to(device=device)
+            labels = batch['labels'].to(device=device)            
+            loss_mask = batch['rmpad_loss_mask'].to(device=device)
+            input_ids = rearrange(input_ids, 'b s ... -> (b s) ...')
+            input_ids = input_ids[word_idx]
+            input_ids = input_ids.unsqueeze(0)
+            labels = labels.view(-1)[word_idx]
+            labels = labels.unsqueeze(0)
+            loss_mask[labels == 1] = 0
+            total_s = cu_seqlen[-1].item()
+            shift_labels = preprocess_labels(labels.squeeze(), cu_seqlen)
+            shift_labels.requires_grad = False
+
+            layer.set_input_ctx((cu_seqlen, total_s))
+            #res = layer.forward(input_id, cu_seqlen, total_s)
+            res = layer.forward(input_ids)
+            loss_arr = vocab_parallel_cross_entropy(res.float(), shift_labels).transpose(0, 1).contiguous()
+            loss_mask = loss_mask.view(-1).float().to(loss_arr.device)
+            loss_mean = torch.sum(loss_arr.view(-1) * loss_mask) / loss_mask.sum().clamp(min=1)
+            losses.append(loss_mean.detach().clone())
+            loss = loss_mean / (gbs)
+            loss.backward()
+            #sample_check_pow2_grad(dict(layer.named_parameters()))
+        loss_report = sum(losses) / len(losses)
+        gather_objs = collect_scalars_across_data_parallel_group([loss_report], rank_generator.get_dp_group())
+        gathered_loss = sum(gather_objs[0]) / dp_size
+        losses = []
+        seen_token = (total_step * seq_len * mbs * gbs * ngpus) / 1024.0 / 1024.0 # In M
+        optimizers.step()
+        end_time = time.perf_counter()
+        if rank == 0 and total_step % 1 == 0:
+            caliberated_grad_norm = optimizers.grad_norm()
+            print(f"[Rank-{rank}] epoch step: {total_step} step_time: {(end_time - start_time):.6f} consumed: {seen_token}M tokens Loss: {gathered_loss} grad_norm: {caliberated_grad_norm} lr: {optimizers.get_last_lr()[0]:.3e}")
+            db_logger.log_step({'training/loss': gathered_loss})
+        total_step += 1
+
+
+    print("All done")
+
+def test_cross_node(ngpus):
+    torch.multiprocessing.spawn(do_main, args=(ngpus,), nprocs=ngpus, daemon=True)
+
+def main():
+    do_main()
+
+if __name__ == "__main__":
+    rank = int(os.environ['RANK'])
+    local_rank = int(os.environ['LOCAL_RANK'])
+    world_size = int(os.environ['WORLD_SIZE'])
+    do_main(rank, local_rank, world_size)

playground/Abbie-h100/trainer_configs/trainer_base.yaml

@@ -0,0 +1,108 @@
+trainer:
+  project_name: thoth_abbie_dev
+  experiment_name: run-${now:%Y-%m-%d}-${now:%H-%M-%S}
+  output_path: runs/${trainer.project_name}/${trainer.experiment_name}
+  resume_path: auto
+  log_interval: 1
+  checkpoint_interval: null
+  checkpoint_hf_model: true
+  save_final_model: true
+  gc_interval: null
+
+  pp: 1
+  ep: 1
+  sp: 1
+
+  seed: 1729
+
+  deterministic: true
+  profile_mode: false
+  debug_steps: null
+
+data:
+  patterns: null
+  iterable: false
+  max_seq_len: 4096
+
+  # Regarding training steps
+  num_training_steps: null
+  num_epoch: 1
+  chunks_per_step: ${eval:'${trainer.pp} * 2'}
+
+  # Batching related
+  micro_batch_size: 1
+  is_continuous_batch: false
+  max_tokens_per_batch: ${data.max_seq_len}
+  max_samples_per_batch: 32
+  pad_to_multiple_of: ${trainer.sp}
+
+  # Other data configs
+  num_workers: 4
+  seed: 52
+  shuffle: true
+  allow_skip_files: false
+  transform_extra_kwargs: null
+
+  # For continuous batching with map-style
+  dataset_meta_paths: null
+
+  # For using multi-source dataloader
+  # (Will be deprecated in favor of multi_source_configs)
+  data_source_metas: null
+  prefetch: true
+
+  # For using multiple dataloaders with MultiSourceDataloader
+  multi_source_configs: null
+
+model:
+  template_path: null
+  pretrained_path: null
+  tokenizer_path: ${model.pretrained_path}
+
+  max_seq_len: ${data.max_seq_len}
+  loss_type: fused_ce_torch
+  aux_loss_coef: null
+  z_loss_coef: null
+
+  recompute_norm: true
+  recompute_attn_up_proj: true
+  recompute_attn_down_proj: true
+  recompute_attn: false
+  recompute_mlp: true
+  recompute_mlp_act: true
+  recompute_dispatch: true
+  recompute_visual: true
+
+  activation_offloading: false
+  visual_activation_offloading: false
+
+  token_dispatch_method: all-to-all
+
+  pp_distributed_dataloading: false
+
+  decoder_first_pipeline_num_layers: null
+  decoder_last_pipeline_num_layers: null
+
+  freeze_decoder_vocab: false
+  freeze_decoder_but_last_n_layers: null
+  freeze_visual_encoder: false
+  freeze_visual_aligner: false
+
+  global_attention_interval: null
+  local_attention_window: null
+
+optim:
+  lr: 1e-5
+  visual_lr: 2e-6
+  lr_warmup_steps_ratio: 0.1
+  lr_schedule: cosine
+  weight_decay: 0.0
+
+  adam_beta1: 0.9
+  adam_beta2: 0.999
+
+  disable_optimizer: false
+
+hydra:
+  run:
+    dir: ${trainer.output_path}

playground/Abbie-h100/trainer_configs/trainer_tivila.yaml

@@ -0,0 +1,15 @@
+defaults:
+  - trainer_base
+  - _self_
+
+data:
+  allow_skip_files: true
+  iterable: true
+  transform_extra_kwargs:
+    allow_skip: true
+    image_min_pixels: null
+    image_max_pixels: null
+    video_min_pixels: null
+    video_max_pixels: 307200
+    video_min_frames: null
+    video_max_frames: 16

playground/Abbie-h100/trainer_utils/common.py

@@ -0,0 +1,120 @@
+import logging
+from typing import Tuple, TypedDict
+
+import torch
+import torch.distributed as dist
+from omegaconf import DictConfig, OmegaConf
+
+from abbie.device_mesh_manager import DMM
+from abbie.gargantua.causal_lm import GenericTransformerForCausalLM, make_model_optimizer
+from abbie.models import load_pretrained_hf_model
+from abbie.utils.metrics import GlobalMetrics
+from abbie.utils.optimizer import MappedOptimizer, PseudoMappedOptimizer
+
+
+class TrainingStats(TypedDict):
+    step_nb: int
+    total_tokens: int
+
+
+def set_qwen_vl_utils_log_level(level=logging.ERROR):
+    try:
+        # Qwen2.5-VL has info logging
+        from qwen_vl_utils.vision_process import logger
+
+        logger.setLevel(level)
+    except ImportError:
+        pass
+
+
+def init_wandb(config: DictConfig):
+    experiment_config = OmegaConf.to_object(config)
+    experiment_config.update({"trainer.world_size": dist.get_world_size()})
+
+    GlobalMetrics.initialize(
+        project_name=config.trainer.project_name,
+        experiment_name=config.trainer.experiment_name,
+        config=experiment_config,
+    )
+
+
+def load_model_and_optimizer(
+    config: DictConfig,
+    num_training_steps: int,
+) -> Tuple[
+    GenericTransformerForCausalLM,
+    MappedOptimizer,
+]:
+    max_batch_size = config.data.micro_batch_size * config.data.chunks_per_step
+    if config.data.is_continuous_batch:
+        max_batch_size = config.data.chunks_per_step
+
+    DMM.log_rank0(f"Loading model from {config.model.pretrained_path}")
+
+    model = load_pretrained_hf_model(
+        config.model.pretrained_path,
+        max_batch_size=max_batch_size,
+        max_seq_len=config.model.max_seq_len,
+        aux_loss_coef=config.model.aux_loss_coef,
+        z_loss_coef=config.model.z_loss_coef,
+        recompute_norm=config.model.recompute_norm,
+        recompute_attn_up_proj=config.model.recompute_attn_up_proj,
+        recompute_attn=config.model.recompute_attn,
+        recompute_attn_down_proj=config.model.recompute_attn_down_proj,
+        recompute_mlp=config.model.recompute_mlp,
+        recompute_mlp_act=config.model.recompute_mlp_act,
+        recompute_dispatch=config.model.recompute_dispatch,
+        recompute_visual=config.model.recompute_visual,
+        activation_offloading=config.model.activation_offloading,
+        visual_activation_offloading=config.model.visual_activation_offloading,
+        token_dispatch_method=config.model.token_dispatch_method,
+        pp_distributed_dataloading=config.model.pp_distributed_dataloading,
+        decoder_first_pipeline_num_layers=config.model.decoder_first_pipeline_num_layers,
+        decoder_last_pipeline_num_layers=config.model.decoder_last_pipeline_num_layers,
+    )
+
+    # Before making optimizer, freeze necessary params first
+    if config.model.freeze_decoder_vocab:
+        model.freeze_vocab()
+    if config.model.freeze_decoder_but_last_n_layers is not None:
+        model.freeze_all_layers_but_last_n(config.model.freeze_decoder_but_last_n_layers)
+
+    if model.config.vision_config is not None:
+        if config.model.freeze_visual_encoder:
+            model.visual.freeze_encoder()
+        if config.model.freeze_visual_aligner:
+            model.visual.freeze_aligner()
+
+    # Initializing model could have created some buffers (like for loading pretrained weights)
+    torch.cuda.empty_cache()
+    DMM.log_rank0(f"Model loaded mem_alloc={torch.cuda.max_memory_allocated() / (1 << 30):.1f}GB")
+
+    total_params = 0
+    total_trainable_params = 0
+    for param in model.parameters():
+        total_params += param.numel()
+        if param.requires_grad:
+            total_trainable_params += param.numel()
+    DMM.log_all_ranks(f"trainable_params={total_trainable_params / 1e9:.3f}B total_params={total_params / 1e9:.3f}B")
+
+    num_warmup_steps = int(num_training_steps * config.optim.lr_warmup_steps_ratio)
+
+    if config.optim.disable_optimizer:
+        optimizer = PseudoMappedOptimizer()
+    else:
+        optimizer = make_model_optimizer(
+            model=model,
+            num_training_steps=num_training_steps,
+            num_warmup_steps=num_warmup_steps,
+            lr=config.optim.lr,
+            visual_lr=config.optim.visual_lr,
+            betas=(config.optim.adam_beta1, config.optim.adam_beta2),
+            weight_decay=config.optim.weight_decay,
+            lr_schedule=config.optim.lr_schedule,
+        )
+
+    # Initializing optimizer could have created some buffers
+    torch.cuda.empty_cache()
+    DMM.log_rank0(f"Optimizers created mem_alloc={torch.cuda.max_memory_allocated() / (1 << 30):.1f}GB")
+
+    return model, optimizer

playground/Abbie-h100/trainer_utils/dataloader.py

@@ -0,0 +1,285 @@
+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

playground/Abbie-h100/trainer_utils/thothvl_transform.py

@@ -0,0 +1,656 @@
+import ast
+import io
+import os
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, List, Optional, Set, Union
+
+import cv2
+import numpy as np
+import pyarrow.parquet as pq
+import torch
+from arpeggio import Chord, DataloaderArgs, create_dataloader, register_transform
+from arpeggio.chord import Chord
+from arpeggio.tuners import Qwen3VLTransform
+from arpeggio.utils.conversation_utils import (
+    chatml_input_ids_to_labels,
+    handle_message_extra_fields,
+    sharegpt_to_hf_format,
+)
+from arpeggio.utils.qwen_vl_utils import get_mrope_index_qwen3_vl
+from decord import VideoReader, cpu
+from PIL import Image
+from qwen_vl_utils import fetch_image, fetch_video, process_vision_info
+from qwen_vl_utils.vision_process import smart_resize
+from torchvision import transforms
+from torchvision.transforms import InterpolationMode
+from transformers import AutoTokenizer
+
+
+DISABLE_CV2_PATCH = os.getenv("DISABLE_CV2_PATCH", "0") == "1"
+
+# ==================== OpenCV Resize Monkey Patch ====================
+# Patch PIL.Image.resize to use OpenCV
+
+_original_pil_resize = Image.Image.resize
+
+_PIL_TO_CV2_INTERP = {
+    Image.Resampling.NEAREST: cv2.INTER_NEAREST,
+    Image.Resampling.BILINEAR: cv2.INTER_LINEAR,
+    Image.Resampling.BICUBIC: cv2.INTER_CUBIC,
+    Image.Resampling.LANCZOS: cv2.INTER_LANCZOS4,
+    # Compat with older PIL versions
+    0: cv2.INTER_NEAREST,
+    2: cv2.INTER_LINEAR,
+    3: cv2.INTER_CUBIC,
+    1: cv2.INTER_LANCZOS4,
+}
+
+
+def _cv2_resize(self, size, resample=None, box=None, reducing_gap=None):
+    """OpenCV-accelerated PIL Image.resize()."""
+    # Fall back to original for box parameter (crop + resize)
+    if box is not None:
+        return _original_pil_resize(self, size, resample=resample, box=box, reducing_gap=reducing_gap)
+
+    if resample is None:
+        resample = Image.Resampling.BICUBIC
+    cv2_interp = _PIL_TO_CV2_INTERP.get(resample, cv2.INTER_LINEAR)
+
+    target_w, target_h = size
+    # Use INTER_AREA for downsampling (better quality)
+    if target_w < self.width or target_h < self.height:
+        cv2_interp = cv2.INTER_AREA
+
+    img_array = np.asarray(self)
+    resized = cv2.resize(img_array, (target_w, target_h), interpolation=cv2_interp)
+    return Image.fromarray(resized)
+
+
+def enable_cv2_resize():
+    """Enable OpenCV-accelerated resize."""
+    Image.Image.resize = _cv2_resize
+
+
+def disable_cv2_resize():
+    """Restore original PIL resize."""
+    Image.Image.resize = _original_pil_resize
+
+
+# Enable by default
+if not DISABLE_CV2_PATCH:
+    enable_cv2_resize()
+
+
+@dataclass
+class VideoData:
+    """Processed video data with metadata."""
+
+    video: Union[torch.Tensor, List[Image.Image]]  # video tensor or PIL frames
+    metadata: dict  # contains fps, total_num_frames, frames_indices
+    sample_fps: float
+
+
+class ThothVLTransform(Qwen3VLTransform):
+    """Qwen3-VL transform that supports Thoth/msswift-style data formats.
+
+    Supports:
+    - content_split: pretrain text data
+    - caption: image captioning data
+    - conversations/messages: multi-turn dialogue
+    - Various image formats: bytes, path, dict, PIL.Image
+    - Various video formats: frames, video bytes, gif
+    - Nested conversations
+    """
+
+    # ==================== Image Processing ====================
+
+    def _read_image(
+        self,
+        image: Union[bytes, str, Image.Image, dict, None],
+        to_pil: bool = False,
+    ) -> Optional[Image.Image]:
+        """Convert various image formats to PIL Image."""
+        if image is None:
+            return None
+
+        if isinstance(image, Image.Image):
+            return image
+
+        if isinstance(image, bytes):
+            return Image.open(io.BytesIO(image))
+
+        if isinstance(image, str):
+            # Path to image - will be handled by fetch_image later
+            return image
+
+        if isinstance(image, dict):
+            if image.get("bytes") is not None:
+                img_bytes = image["bytes"]
+                if isinstance(img_bytes, Image.Image):
+                    return img_bytes
+                return Image.open(io.BytesIO(img_bytes))
+            elif image.get("path") is not None:
+                return image["path"]
+            return None
+
+        if isinstance(image, (np.float64, np.float32)):
+            return None
+
+        raise ValueError(f"Unsupported image type: {type(image)}")
+
+    def _process_images(self, item: dict) -> Optional[List]:
+        """Extract and process images from item."""
+        raw_images = None
+
+        if "jpg" in item:
+            raw_images = [item.pop("jpg")]
+        elif "image" in item:
+            image_data = item.pop("image")
+            if image_data is not None and not isinstance(image_data, (np.float64, np.float32)):
+                raw_images = [image_data]
+        elif "images" in item:
+            raw_images = item.pop("images")
+            if isinstance(raw_images, np.ndarray):
+                raw_images = raw_images.tolist()
+            elif isinstance(raw_images, dict):
+                raw_images = [raw_images]
+
+        if not raw_images:
+            return None
+
+        images = []
+        for raw in raw_images:
+            img = self._read_image(raw, to_pil=True)
+            if img is None:
+                continue
+
+            if isinstance(img, str):
+                # Path - use fetch_image
+                ele = {"type": "image", "image": img}
+                self._patch_visual_element(ele)
+                img = fetch_image(ele, image_patch_size=self._patch_size)
+
+            images.append(img)
+
+        return images if images else None
+
+    # ==================== Video Processing ====================
+
+    def _read_gif(self, gif_bytes: bytes) -> List[Image.Image]:
+        """Extract frames from a GIF."""
+        if not isinstance(gif_bytes, bytes):
+            raise TypeError(f"Unsupported gif type: {type(gif_bytes)}")
+
+        frames = []
+        with io.BytesIO(gif_bytes) as byte_stream:
+            with Image.open(byte_stream) as img:
+                try:
+                    while True:
+                        frames.append(img.copy())
+                        img.seek(img.tell() + 1)
+                except EOFError:
+                    pass
+        return frames
+
+    def _decode_video_bytes(self, video_bytes: bytes) -> tuple[torch.Tensor, dict, float]:
+        """Decode video from bytes using decord.
+
+        Returns (video_tensor, metadata, sample_fps)
+        """
+        vr = VideoReader(io.BytesIO(video_bytes), ctx=cpu(0), num_threads=1)
+
+        total_frames = len(vr)
+        fps = vr.get_avg_fps()
+
+        max_num_frames = self._video_ele_kwargs.get("max_frames") or int(os.environ.get("FPS_MAX_FRAMES", 32))
+
+        if total_frames <= max_num_frames:
+            indices = list(range(total_frames))
+        else:
+            indices = np.linspace(0, total_frames - 1, max_num_frames, dtype=int).tolist()
+
+        # numpy array: [N, H, W, C]
+        frames = vr.get_batch(indices).asnumpy()
+
+        #  [N, C, H, W]
+        video_tensor = torch.from_numpy(frames).permute(0, 3, 1, 2)
+
+        sample_fps = len(indices) / total_frames * fps if total_frames > 0 else 1.0
+
+        metadata = {
+            "fps": fps,
+            "total_num_frames": total_frames,
+            "frames_indices": torch.tensor(indices),
+        }
+
+        return video_tensor, metadata, sample_fps
+
+    def _process_videos(self, item: dict) -> Optional[List[VideoData]]:
+        """Extract and process videos from item.
+
+        Returns a list of VideoData, each containing video tensor/frames and metadata.
+
+        Supported formats:
+            - frames: List[bytes] - Each bytes is an image (frame)
+            - video: bytes - Raw mp4 video bytes
+            - video: str - Video file path
+            - gif: bytes - GIF animation bytes
+            - videos: List[...] - Multiple videos in various formats
+        """
+        max_num_frames = int(os.environ.get("FPS_MAX_FRAMES", 16))
+        raw_videos = None
+
+        if "frames" in item:
+            raw_frames = item.pop("frames")
+            frames = []
+            for frame in raw_frames:
+                img = self._read_image(frame)
+                if img is not None and isinstance(img, Image.Image):
+                    frames.append(img)
+
+            if len(frames) > max_num_frames:
+                indices = np.linspace(0, len(frames) - 1, max_num_frames, dtype=int)
+                frames = [frames[i] for i in indices]
+
+            if frames:
+                raw_videos = [frames]
+        elif "video" in item:
+            raw_videos = [item.pop("video")]
+        elif "gif" in item:
+            raw_videos = [self._read_gif(item.pop("gif"))]
+        elif "videos" in item:
+            raw_videos = item.pop("videos")
+            if isinstance(raw_videos, np.ndarray):
+                raw_videos = raw_videos.tolist()
+                if raw_videos and isinstance(raw_videos[0], np.ndarray):
+                    raw_videos = [v.tolist() for v in raw_videos]
+
+        if not raw_videos:
+            return None
+
+        results = []
+
+        try:
+            for raw in raw_videos:
+                if isinstance(raw, list) and raw and isinstance(raw[0], Image.Image):
+                    # List of PIL Images (frames)
+                    num_frames = len(raw)
+                    metadata = {
+                        "fps": 1.0,
+                        "total_num_frames": num_frames,
+                        "frames_indices": torch.arange(num_frames),
+                    }
+                    results.append(VideoData(video=raw, metadata=metadata, sample_fps=1.0))
+
+                elif isinstance(raw, list) and raw and isinstance(raw[0], bytes):
+                    total_frames = len(raw)
+
+                    if total_frames > max_num_frames:
+                        indices = np.linspace(0, total_frames - 1, max_num_frames, dtype=int)
+                    else:
+                        indices = range(total_frames)
+
+                    frames = []
+                    for i in indices:
+                        img = self._read_image(raw[i])
+                        if img is not None and isinstance(img, Image.Image):
+                            frames.append(img)
+
+                    if frames:
+                        num_frames = len(frames)
+                        metadata = {
+                            "fps": 1.0,
+                            "total_num_frames": total_frames,
+                            "frames_indices": torch.tensor(
+                                list(indices) if total_frames > max_num_frames else list(range(num_frames))
+                            ),
+                        }
+                        results.append(VideoData(video=frames, metadata=metadata, sample_fps=1.0))
+
+                elif isinstance(raw, bytes):
+                    # Video bytes - use decord
+                    video_tensor, metadata, sample_fps = self._decode_video_bytes(raw)
+                    results.append(VideoData(video=video_tensor, metadata=metadata, sample_fps=sample_fps))
+
+                elif isinstance(raw, str):
+                    # Video file path
+                    ele = {"type": "video", "video": raw}
+                    self._patch_visual_element(ele)
+                    result, sample_fps = fetch_video(
+                        ele,
+                        image_patch_size=self._patch_size,
+                        return_video_sample_fps=True,
+                        return_video_metadata=True,
+                    )
+
+                    if isinstance(result, tuple):
+                        video_tensor, metadata = result
+                    else:
+                        video_tensor = result
+                        num_frames = video_tensor.shape[0]
+                        metadata = {
+                            "fps": sample_fps,
+                            "total_num_frames": num_frames,
+                            "frames_indices": torch.arange(num_frames),
+                        }
+                    results.append(VideoData(video=video_tensor, metadata=metadata, sample_fps=sample_fps))
+
+                elif isinstance(raw, torch.Tensor):
+                    num_frames = raw.shape[0]
+                    metadata = {
+                        "fps": 1.0,
+                        "total_num_frames": num_frames,
+                        "frames_indices": torch.arange(num_frames),
+                    }
+                    results.append(VideoData(video=raw, metadata=metadata, sample_fps=1.0))
+        except Exception as e:
+            print(f"_process_videos error: {e}")
+            raise e
+
+        return results if results else None
+
+    # ==================== Conversation Processing ====================
+
+    def _normalize_message_format(self, messages: List[Dict]) -> List[Dict]:
+        """Convert from/value format to role/content format and filter system messages.
+
+        Handles:
+        - from: human/user -> role: user
+        - from: gpt/assistant -> role: assistant
+        - from: system -> filtered out
+        - value -> content
+        - Dirty data fix: if assistant message contains <image>/<video>, swap roles
+        """
+        if isinstance(messages, np.ndarray):
+            messages = messages.tolist()
+        elif isinstance(messages, str):
+            messages = ast.literal_eval(messages)
+
+        normalized = []
+        for msg in messages:
+            # Skip system messages
+            if msg.get("from") == "system" or msg.get("role") == "system":
+                continue
+
+            new_msg = {}
+
+            # Handle role/from
+            if "role" in msg:
+                new_msg["role"] = msg["role"]
+            elif "from" in msg:
+                from_value = msg["from"]
+                if from_value in ("human", "user"):
+                    new_msg["role"] = "user"
+                elif from_value in ("gpt", "assistant"):
+                    new_msg["role"] = "assistant"
+                else:
+                    new_msg["role"] = from_value
+
+            # Handle content/value
+            if "content" in msg:
+                new_msg["content"] = msg["content"]
+            elif "value" in msg:
+                new_msg["content"] = msg["value"]
+
+            normalized.append(new_msg)
+
+        # Fix dirty data: if assistant message contains <image>/<video>, swap roles
+        normalized = self._fix_misplaced_roles(normalized)
+
+        return normalized
+
+    def _fix_misplaced_roles(self, messages: List[Dict]) -> List[Dict]:
+        """Fix dirty data where assistant messages contain <image>/<video>.
+
+        Detection pattern:
+        - First message is from assistant AND contains <image>/<video>
+        - Messages alternate between roles
+
+        Fix: Swap all user <-> assistant roles
+        """
+        if not messages:
+            return messages
+
+        def _contains_media(content) -> bool:
+            if not isinstance(content, str):
+                return False
+            return "<image>" in content or "<video>" in content
+
+        # Check first message
+        first_msg = messages[0]
+        first_role = first_msg.get("role", "")
+        first_content = first_msg.get("content", "")
+
+        # Only fix if: first message is assistant AND contains media
+        if first_role != "assistant" or not _contains_media(first_content):
+            return messages
+
+        # Additional validation: check if this looks like a swapped conversation
+        # (i.e., roles alternate properly, just in wrong order)
+        if len(messages) >= 2:
+            second_role = messages[1].get("role", "")
+            # Expected pattern after fix: user, assistant, user, assistant...
+            # Current pattern (wrong): assistant, user, assistant, user...
+            if second_role != "user":
+                # Doesn't match expected dirty pattern, don't fix
+                return messages
+
+        # Swap all roles
+        role_map = {"user": "assistant", "assistant": "user"}
+        fixed = []
+        for msg in messages:
+            new_msg = msg.copy()
+            if new_msg.get("role") in role_map:
+                new_msg["role"] = role_map[new_msg["role"]]
+            fixed.append(new_msg)
+
+        return fixed
+
+    def _replace_image_with_video_placeholder(self, messages: List[Dict]) -> List[Dict]:
+        """Replace <image> placeholders with <video> when videos are present."""
+        for msg in messages:
+            if "value" in msg:
+                msg["value"] = msg["value"].replace("<image>", "<video>")
+            elif "content" in msg:
+                msg["content"] = msg["content"].replace("<image>", "<video>")
+        return messages
+
+    def _is_nested_conversation(self, messages) -> bool:
+        """Check if messages contain nested conversations."""
+        if not messages:
+            return False
+        return isinstance(messages[0], (np.ndarray, list))
+
+    # ==================== Main Preprocessing Methods ====================
+
+    def preprocess_pretrain(self, item: dict) -> Chord:
+        """Process pretrain-style data (content_split)."""
+        item = dict(item)
+
+        content = item.pop("content_split")
+        messages = [{"role": "assistant", "content": content}]
+
+        # Process any images
+        images = self._process_images(item)
+
+        text = self.processor.apply_chat_template(messages, tokenize=False)
+
+        extra_info = item.pop("extra_info", {})
+        if self.add_raw:
+            extra_info["raw_messages"] = messages
+
+        return self._make_model_inputs(
+            text=text,
+            images=images,
+            extra_info=extra_info,
+            do_resize=True,
+        )
+
+    def preprocess_caption(self, item: dict) -> Chord:
+        """Process image captioning data."""
+        item = dict(item)
+
+        caption = item.pop("caption")
+        messages = [
+            {"role": "user", "content": "<image>"},
+            {"role": "assistant", "content": caption},
+        ]
+
+        # Process images
+        images = self._process_images(item)
+
+        # Convert to HF format for apply_chat_template
+        prompt = sharegpt_to_hf_format(messages)
+        text = self.processor.apply_chat_template(prompt, tokenize=False)
+
+        extra_info = item.pop("extra_info", {})
+        if self.add_raw:
+            extra_info["raw_messages"] = messages
+
+        return self._make_model_inputs(
+            text=text,
+            images=images,
+            extra_info=extra_info,
+            do_resize=True,
+        )
+
+    def preprocess_conversation(self, item: dict) -> Chord:
+        """Process conversation/dialogue data."""
+        item = dict(item)
+
+        # Get messages from either 'messages' or 'conversations' key
+        if "messages" in item:
+            messages = item.pop("messages")
+        elif "conversations" in item:
+            messages = item.pop("conversations")
+        else:
+            raise ValueError("No messages or conversations found in item")
+
+        messages = self._normalize_message_format(messages)
+
+        # Process images and videos
+        images = self._process_images(item)
+        video_data_list = self._process_videos(item)
+
+        videos = None
+        video_metadatas = None
+        video_kwargs = {"do_sample_frames": False}
+
+        if video_data_list:
+            messages = self._replace_image_with_video_placeholder(messages)
+
+            videos = [vd.video for vd in video_data_list]
+            video_metadatas = [vd.metadata for vd in video_data_list]
+            fps_list = [vd.sample_fps for vd in video_data_list]
+            video_kwargs["fps"] = fps_list
+
+        # Convert to HF format
+        prompt = sharegpt_to_hf_format(messages)
+        text = self.processor.apply_chat_template(prompt, tokenize=False)
+
+        extra_info = item.pop("extra_info", {})
+        if self.add_raw:
+            extra_info["raw_messages"] = messages
+
+        return self._make_model_inputs(
+            text=text,
+            images=images,
+            videos=videos,
+            video_metadatas=video_metadatas if video_metadatas else None,
+            extra_info=extra_info,
+            do_resize=True,
+            **video_kwargs,
+        )
+
+    def _process_nested_conversations(self, item: dict) -> List[Chord]:
+        """Process nested conversations into a list of Chords."""
+        base_item = dict(item)
+
+        if "messages" in base_item:
+            nested_convs = base_item.pop("messages")
+        else:
+            nested_convs = base_item.pop("conversations")
+
+        if isinstance(nested_convs, np.ndarray):
+            nested_convs = nested_convs.tolist()
+
+        results = []
+        for single_conv in nested_convs:
+            if isinstance(single_conv, np.ndarray):
+                single_conv = single_conv.tolist()
+
+            single_item = deepcopy(base_item)
+            single_item["messages"] = single_conv
+
+            chord = self.preprocess_conversation(single_item)
+            results.append(chord)
+
+        return results
+
+    def preprocess(self, item: dict) -> Union[Chord, List[Chord]]:
+        """Main preprocessing entry point.
+
+        Please refer https://code.byted.org/Thoth/ms-swift/blob/dev.gyf.thoth_vl.hdfs_support/swift/llm/dataset/preprocessor/extra.py
+
+        Handles various data formats from msswift:
+        - content_split: pretrain text data
+        - caption: image captioning data
+        - messages/conversations: multi-turn dialogue (including nested)
+        """
+        try:
+            item = dict(item)  # Shallow copy
+
+            # Handle content_split (pretrain style)
+            if "content_split" in item:
+                return self.preprocess_pretrain(item)
+
+            # Handle caption (image captioning style)
+            if "caption" in item:
+                return self.preprocess_caption(item)
+
+            # Handle conversations/messages
+            if "conversations" in item or "messages" in item:
+                # Get the conversation data
+                conv_key = "messages" if "messages" in item else "conversations"
+                conv_data = item[conv_key]
+
+                if isinstance(conv_data, np.ndarray):
+                    conv_data = conv_data.tolist()
+                elif isinstance(conv_data, str):
+                    conv_data = ast.literal_eval(conv_data)
+
+                # Check for nested conversations
+                if self._is_nested_conversation(conv_data):
+                    item[conv_key] = conv_data
+                    return self._process_nested_conversations(item)
+
+                return self.preprocess_conversation(item)
+
+            # Fallback to parent class behavior
+            if self.prompt_key in item:
+                return super().preprocess_conversation(item)
+            elif self.document_key in item:
+                return super().preprocess_document(item)
+
+            raise RuntimeError(f"Sample contained no usable fields: {list(item.keys())}")
+
+        except Exception as e:
+            if not self.allow_skip:
+                raise e
+
+            if self.should_use_mrope:
+                position_ids = torch.zeros(3, 1, 0, dtype=torch.long)
+            else:
+                position_ids = torch.zeros(1, 0, dtype=torch.long)
+
+            return {
+                "input_ids": torch.zeros(1, 0, dtype=torch.long),
+                "position_ids": position_ids,
+                "attention_mask": torch.zeros(1, 0, dtype=torch.long),
+                "labels": torch.zeros(1, 0, dtype=torch.long),
+                "extra_info": [{}],
+            }
+
+
+register_transform("thoth_vl", ThothVLTransform)