Upload FAI-Bench task files batch 63

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/gptoss/01_convert_from_hf.py

@@ -0,0 +1,55 @@
+# Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+
+"""Convert HuggingFace checkpoints to Megatron format."""
+
+import os
+import argparse
+
+from megatron.bridge import AutoBridge
+
+def _parse_args():
+    parser = argparse.ArgumentParser(description="Convert HF LLMs to Megatron format")
+    parser.add_argument(
+        "--hf-model",
+        type=str,
+        required=True,
+        help="HuggingFace model identifier or path",
+    )
+    parser.add_argument(
+        "--save-path",
+        type=str,
+        default=None,
+        help="Path to save the converted Megatron checkpoint",
+    )
+    parser.add_argument('--local-rank', '--local_rank', type=int, default=0)
+    return parser.parse_args()
+
+if __name__ == "__main__":
+    args = _parse_args()
+    HF_MODEL = args.hf_model
+    SAVE_PATH = args.save_path
+    WORLD_SIZE = int(os.environ.get("WORLD_SIZE", 1))
+
+    if SAVE_PATH is None:
+        SAVE_PATH = f"./megatron_checkpoints/{HF_MODEL.replace('/', '_')}"
+    
+    print(f"Converting {HF_MODEL} to Megatron format...")
+    print(f"Save path: {SAVE_PATH}")
+    
+    bridge = AutoBridge.from_hf_pretrained(HF_MODEL, trust_remote_code=True)
+    provider = bridge.to_megatron_provider()
+    # Update these configs as needed
+    provider.expert_tensor_parallel_size = 1
+    provider.tensor_model_parallel_size = 1
+    provider.pipeline_model_parallel_size = WORLD_SIZE
+    provider.finalize()
+    
+    model = provider.provide_distributed_model(wrap_with_ddp=False)
+    
+    bridge.save_megatron_model(
+        model,
+        SAVE_PATH,
+        hf_tokenizer_path=HF_MODEL
+    )
+    
+    print(f"Saved Megatron checkpoint to {SAVE_PATH}")

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/gptoss/02_train.sh

@@ -0,0 +1,259 @@
+#!/bin/bash
+
+export CUDA_DEVICE_MAX_CONNECTIONS=${CUDA_DEVICE_MAX_CONNECTIONS:-1}
+
+
+# Setup arguments with defaults
+CHECKPOINT_PATH="NO_VALUE_PROVIDED"
+TENSORBOARD_LOGS_PATH="./tensorboard_logs/"
+TOKENIZER_ARG="MOCK"
+DATA_ARG="MOCK"
+DISTRIBUTED_CONFIG_FILE=""
+
+# Parse command line arguments
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --checkpoint-path)
+            CHECKPOINT_PATH="$2"
+            shift 2
+            ;;
+        --tensorboard-logs-path)
+            TENSORBOARD_LOGS_PATH="$2"
+            shift 2
+            ;;
+        --tokenizer)
+            TOKENIZER_ARG="$2"
+            shift 2
+            ;;
+        --data)
+            DATA_ARG="$2"
+            shift 2
+            ;;
+        --distributed-config-file)
+            DISTRIBUTED_CONFIG_FILE="$2"
+            shift 2
+            ;;
+        -h|--help)
+            echo "Usage: $0 [OPTIONS]"
+            echo "Options:"
+            echo "  --checkpoint-path PATH          Path to Megatron checkpoint"
+            echo "  --tensorboard-logs-path PATH    Path to TensorBoard logs"
+            echo "  --tokenizer PATH|MOCK           Path to tokenizer model, or 'MOCK' (default: MOCK)"
+            echo "  --data PATH|MOCK                Data prefix, or 'MOCK' (default: MOCK)"
+            echo "  --distributed-config-file FILE       Path to distributed training config file"
+            echo "  -h, --help                      Show this help message"
+            exit 0
+            ;;
+        *)
+            echo "Unknown option: $1"
+            echo "Use --help for usage information"
+            exit 1
+            ;;
+    esac
+done
+
+# Check if checkpoint path exists
+if [ ! -d "$CHECKPOINT_PATH" ]; then
+    echo "Error: Checkpoint path does not exist: $CHECKPOINT_PATH"
+    exit 1
+fi
+echo "Checkpoint path exists: $CHECKPOINT_PATH"
+
+# Check if tensorboard logs path exists
+if [ ! -d "$TENSORBOARD_LOGS_PATH" ]; then
+    echo "Warning: TensorBoard logs path does not exist. Creating: $TENSORBOARD_LOGS_PATH"
+    mkdir -p "$TENSORBOARD_LOGS_PATH"
+fi
+echo "TensorBoard logs path exists: $TENSORBOARD_LOGS_PATH"
+
+# NOTE: by default we use 8 GPUs
+# These values will be over-written below with environmental variables
+GPUS_PER_NODE=8
+NUM_NODES=1
+MASTER_ADDR="localhost"
+MASTER_PORT=6000
+NODE_RANK=0
+
+# Load distributed config from file if provided
+if [ -n "$DISTRIBUTED_CONFIG_FILE" ]; then
+    if [ ! -f "$DISTRIBUTED_CONFIG_FILE" ]; then
+        echo "Warning: Distributed config file does not exist: $DISTRIBUTED_CONFIG_FILE"
+        echo "Continuing with default distributed training settings."
+    else
+        echo "Loading distributed config from: $DISTRIBUTED_CONFIG_FILE"
+        source "$DISTRIBUTED_CONFIG_FILE"
+    fi
+fi
+
+# Override with environment variables if set
+GPUS_PER_NODE=${GPUS_PER_NODE:-8}
+NUM_NODES=${NUM_NODES:-1}
+MASTER_ADDR=${MASTER_ADDR:-localhost}
+MASTER_PORT=${MASTER_PORT:-6000}
+NODE_RANK=${NODE_RANK:-0}
+WORLD_SIZE=$(($GPUS_PER_NODE*$NUM_NODES))
+
+# Path to the pretrain_gpt.py script, assuming this script is run from the root of the Megatron-LM repository
+PRETRAIN_SCRIPT_PATH="pretrain_gpt.py"
+
+# Data cache path (useful for both mock and real data)
+DATA_CACHE_PATH="${PWD}/benchmark_cache_gpt_oss_20b"
+mkdir -p "$DATA_CACHE_PATH"
+
+DISTRIBUTED_ARGS=(
+    --nproc_per_node $GPUS_PER_NODE
+    --nnodes $NUM_NODES
+    --master_addr $MASTER_ADDR
+    --master_port $MASTER_PORT
+    --node_rank $NODE_RANK
+)
+
+# NOTE: we only set pipeline parallelism to be the number of GPUs
+# Adjust each value based on your setup.
+TP_SIZE=1     
+EP_SIZE=1     
+PP_SIZE=${WORLD_SIZE}     
+MICRO_BATCH_SIZE=1
+GLOBAL_BATCH_SIZE=128
+NUM_LAYERS=12
+DTYPE="fp8"
+SEQ_LENGTH=8192
+MAX_POSITION_EMBEDDINGS=8192
+TRAIN_SAMPLES=1953125000
+LR_DECAY_SAMPLES=1949218748
+
+MODEL_ARGS=(
+    --no-masked-softmax-fusion
+    --transformer-impl transformer_engine
+    --disable-bias-linear
+    --untie-embeddings-and-output-weights
+    --no-rope-fusion
+    --normalization RMSNorm
+    --num-layers ${NUM_LAYERS}
+    --hidden-size 512
+    --ffn-hidden-size 2048
+    --num-attention-heads 64
+    --group-query-attention
+    --num-query-groups 8
+    --seq-length ${SEQ_LENGTH}
+    --max-position-embeddings ${MAX_POSITION_EMBEDDINGS}
+    --use-mcore-models
+    --rotary-percent 1.0
+    --rope-type rope
+    --position-embedding-type rope
+    --rotary-base 10000
+    --no-bias-gelu-fusion
+    --export-force-local-attention
+    --no-bias-dropout-fusion
+    --quick-geglu
+    --glu-linear-offset 1.0
+    --softmax-type learnable
+    --window-attn-skip-freq 2
+    --activation-func-clamp-value 7.0
+    --window-size 127,0
+    --enable-gpt-oss
+)
+
+MOE_ARGS=(
+    --num-experts 4
+    --moe-router-topk 2
+    --moe-router-load-balancing-type aux_loss
+    --moe-aux-loss-coeff 1e-3
+    --moe-grouped-gemm
+    --moe-token-dispatcher-type alltoall
+    --overlap-param-gather
+    --overlap-grad-reduce
+    --moe-ffn-hidden-size 2048
+    --moe-router-dtype fp32
+    --moe-z-loss-coeff 1e-3
+    --moe-permute-fusion
+)
+
+DATA_ARGS_LIST=()
+if [[ "$TOKENIZER_ARG" == "MOCK" ]] || [[ "$DATA_ARG" == "MOCK" ]] || [[ -z "$TOKENIZER_ARG" ]]; then
+    DATA_ARGS_LIST+=(
+        "--mock-data"
+        "--tokenizer-type NullTokenizer"
+        "--vocab-size 128256" 
+        "--data-cache-path ${DATA_CACHE_PATH}"
+        "--tiktoken-pattern v2" 
+        "--split '99,1,0'"
+        "--no-create-attention-mask-in-dataloader"
+        "--no-mmap-bin-files"
+        "--num-workers 1"
+    )
+else
+    # Settings for real data
+    DATA_ARGS_LIST+=(
+        "--data-path $DATA_ARG"
+        "--tokenizer-type HuggingFaceTokenizer" 
+        "--tokenizer-model $TOKENIZER_ARG"
+        "--data-cache-path ${DATA_CACHE_PATH}"
+        "--split '99,1,0'"
+        "--no-create-attention-mask-in-dataloader"
+        "--no-mmap-bin-files"
+        "--num-workers 1"
+        # Note: --vocab-size might be inferred by HuggingFaceTokenizer or might need to be explicit.
+        "--vocab-size 128256"
+    )
+fi
+
+TRAINING_ARGS=(
+    --micro-batch-size ${MICRO_BATCH_SIZE}
+    --global-batch-size ${GLOBAL_BATCH_SIZE}
+    --lr 1.0e-5
+    --train-samples ${TRAIN_SAMPLES}
+    --lr-decay-samples ${LR_DECAY_SAMPLES}
+    --lr-decay-style cosine
+    --min-lr 1.0e-6
+    --weight-decay 0.1
+    --lr-warmup-fraction 0.05
+    --clip-grad 1.0
+    --bf16
+    --use-flash-attn
+    --attention-softmax-in-fp32
+    --accumulate-allreduce-grads-in-fp32
+    --disable-bf16-reduced-precision-matmul
+    --recompute-activations
+)
+
+MODEL_PARALLEL_ARGS=(
+    --tensor-model-parallel-size ${TP_SIZE}
+    --pipeline-model-parallel-size ${PP_SIZE}
+    --expert-model-parallel-size ${EP_SIZE}
+    --sequence-parallel
+    --context-parallel-size 1
+    --use-distributed-optimizer
+    --fp8-format hybrid
+    --fp8-param-gather
+    --fp8-amax-compute-algo max
+    --fp8-amax-history-len 1024
+)
+    
+LOGGING_ARGS=(
+    --log-interval 1
+    --save-interval 10000
+    --eval-interval 50000000
+    --eval-iters 0
+    --save $CHECKPOINT_PATH
+    --tensorboard-dir "${CHECKPOINT_PATH}/tensorboard"
+    --moe-per-layer-logging
+    --no-load-optim
+    --no-load-rng
+    --log-throughput
+)
+
+# Ensure pretrain_gpt.py is found
+if [ ! -f "$PRETRAIN_SCRIPT_PATH" ]; then
+    echo "Error: pretrain_gpt.py not found at $PRETRAIN_SCRIPT_PATH"
+    echo "Please ensure you are running this script from the root of the Megatron-LM repository, and pretrain_gpt.py is present."
+    exit 1
+fi
+
+python -m torch.distributed.run ${DISTRIBUTED_ARGS[@]} ${PRETRAIN_SCRIPT_PATH} \
+    ${MODEL_ARGS[@]} \
+    ${MOE_ARGS[@]} \
+    ${DATA_ARGS_LIST[@]} \
+    ${TRAINING_ARGS[@]} \
+    ${MODEL_PARALLEL_ARGS[@]} \
+    ${LOGGING_ARGS[@]}

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/gptoss/03_convert_to_hf.py

@@ -0,0 +1,52 @@
+# Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+
+"""Convert HuggingFace checkpoints to Megatron format."""
+
+import os
+import argparse
+
+from megatron.bridge import AutoBridge
+
+def _parse_args():
+    parser = argparse.ArgumentParser(description="Convert Megatron LLMs to HuggingFace format")
+    parser.add_argument(
+        "--hf-model",
+        type=str,
+        required=True,
+        help="HuggingFace model identifier or path to load config from",
+    )
+    parser.add_argument(
+        "--megatron-model",
+        type=str,
+        required=True,
+        help="Megatron model identifier or path",
+    )
+    parser.add_argument(
+        "--save-path",
+        type=str,
+        default=None,
+        help="Path to save the converted HuggingFace checkpoint",
+    )
+    parser.add_argument('--local-rank', '--local_rank', type=int, default=0)
+    return parser.parse_args()
+
+if __name__ == "__main__":
+    args = _parse_args()
+    HF_MODEL = args.hf_model
+    MEGATRON_MODEL = args.megatron_model
+    SAVE_PATH = args.save_path
+    WORLD_SIZE = int(os.environ.get("WORLD_SIZE", 1))
+
+    if SAVE_PATH is None:
+        SAVE_PATH = f"./huggingface_checkpoints/{MEGATRON_MODEL.replace('/', '_')}"
+    
+    print(f"Converting {MEGATRON_MODEL} to HuggingFace {HF_MODEL} format...")
+    print(f"Save path: {SAVE_PATH}")
+    
+    bridge = AutoBridge.from_hf_pretrained(HF_MODEL, trust_remote_code=True)
+    bridge.export_ckpt(
+        MEGATRON_MODEL,
+        SAVE_PATH,
+    )
+    
+    print(f"Saved HuggingFace checkpoint to {SAVE_PATH}")

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/gptoss/README.md

@@ -0,0 +1,153 @@
+# GPT-OSS Training Tutorial
+
+## Step 0: Install Dependencies
+
+### Using Megatron Bridge
+
+[Megatron-Bridge](https://github.com/NVIDIA-NeMo/Megatron-Bridge)
+
+Megatron Bridge provides a quick and convenient way to convert HuggingFace checkpoints to the Megatron format used by Megatron-LM. Follow the instructions in the [Megatron-Bridge Installation](https://github.com/NVIDIA-NeMo/Megatron-Bridge/blob/main/README.md#-installation) to run the nemo docker container and convert checkpoints (via mounted volumes - make sure that the huggingface cache location AND the megatron checkpoint locations are properly mounted, otherwise you may not be saving the converted model to disk correctly).
+
+Below is an example of how to use Megatron-Bridge inside the pytorch container to convert a HuggingFace model checkpoint to Megatron format.
+
+Reference: [Megatron-Bridge Dockerfile](https://github.com/NVIDIA-NeMo/Megatron-Bridge/blob/main/docker/Dockerfile.ci)
+
+Inside the [pytorch container](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/pytorch) run the following commands to install Megatron-Bridge:
+```bash
+cd /opt
+git clone --recursive https://github.com/NVIDIA-NeMo/Megatron-Bridge.git
+cd Megatron-Bridge
+
+# Make sure submodules are initialized (for 3rdparty/Megatron-LM)
+git submodule update --init --recursive
+
+export PATH="/root/.local/bin:$PATH"
+export UV_PROJECT_ENVIRONMENT=/opt/venv
+export VIRTUAL_ENV=/opt/venv
+export PATH="$UV_PROJECT_ENVIRONMENT/bin:$PATH"
+export UV_LINK_MODE=copy
+export UV_VERSION="0.7.2"
+
+# Install UV
+curl -LsSf https://astral.sh/uv/${UV_VERSION}/install.sh | sh
+
+# Create virtual environment and build the package
+uv venv ${UV_PROJECT_ENVIRONMENT} --system-site-packages
+
+uv sync --locked --only-group build
+uv sync --locked --link-mode copy --all-extras --all-groups
+
+uv pip install --no-deps -e .
+
+source ${UV_PROJECT_ENVIRONMENT}/bin/activate
+```
+
+### Setup Environment
+
+```bash
+export HOST_MEGATRON_LM_DIR="/path/to/your/host/megatron-lm"
+git clone https://github.com/NVIDIA/Megatron-LM.git "$HOST_MEGATRON_LM_DIR"
+cd "$HOST_MEGATRON_LM_DIR"
+```
+
+```bash
+export HF_TOKEN={your_hf_token_here}
+```
+
+## Step 1: Convert HuggingFace to Megatron (Optional - skip if you already have a Megatron checkpoint)
+
+Set `--nproc-per-node` to be the number of GPUs per node. Set `hf_model_name` to be the Huggingface model e.g. `openai/gpt-oss-20b`
+
+```bash
+python3 -m torch.distributed.launch --nproc-per-node=8 examples/gptoss/01_convert_from_hf.py --hf-model openai/gpt-oss-20b
+```
+
+## Step 2: Train from Scratch
+
+To train from scratch first follow the steps below to setup the environment appropriately before running the training script in docker. Even though we are running the same container as before, it is better to restart the container to ensure a clean environment and that all environment and docker variables are set correctly. For the following example we used 8x GB300, but you should change the number of GPUs and nodes as needed.
+
+### Setup Environment
+
+```bash
+# Change these based on model and directory from previous conversion step
+export MODEL_DIR_NAME="openai_gpt-oss_20b"
+
+export HOST_CHECKPOINT_PATH="./megatron_checkpoints/${MODEL_DIR_NAME}"
+export HOST_TENSORBOARD_LOGS_PATH="./tensorboard_logs/${MODEL_DIR_NAME}"
+```
+
+By default we will use mock data to train the model in the example below. To use your own data, set the following environment variables:
+
+```bash
+# Optional: For real data
+export HOST_TOKENIZER_MODEL_PATH="/path/to/host/tokenizer.model"
+export HOST_DATA_PREFIX="/path/to/host/mydata_prefix"
+```
+
+### Setup Training Configurations
+
+Run the following to create a `distributed_config.env` file with the appropriate distributed training configurations. Change the values as needed for your setup. This file will override the default values in `02_train.sh`.
+
+```bash
+cat > ./distributed_config.env << 'EOF'
+GPUS_PER_NODE=8
+NUM_NODES=1
+MASTER_ADDR=localhost
+MASTER_PORT=6000
+NODE_RANK=0
+EOF
+```
+
+### Run Container with Mounted Volumes
+
+**NOTE:** This container runs the example training script `02_train.sh` located in the `examples/gptoss` directory. By default, we have only set pipeline parallelism to be the number of GPUs. Adjust TP_SIZE, EP_SIZE, PP_SIZE, etc. in `02_train.sh`. You can also adjust modify `--hidden-size`, `--ffn-hidden-size`, `--num-attention-heads`, `NUM_LAYERS`, etc. 
+
+To train using mock data, run the following command:
+```bash
+PYTORCH_IMAGE="nvcr.io/nvidia/pytorch:25.12-py3"
+
+docker run --rm --gpus all --ipc=host --ulimit memlock=-1 \
+  -v "${HOST_MEGATRON_LM_DIR}:/workspace/megatron-lm" \
+  -v "${HOST_CHECKPOINT_PATH}:/workspace/checkpoints" \
+  -v "${HOST_TENSORBOARD_LOGS_PATH}:/workspace/tensorboard_logs" \
+  -v "./distributed_config.env:/workspace/megatron-lm/examples/gptoss/distributed_config.env" \
+  --workdir /workspace/megatron-lm \
+  $PYTORCH_IMAGE \
+  bash examples/gptoss/02_train.sh \
+    --checkpoint-path /workspace/checkpoints \
+    --tensorboard-logs-path /workspace/tensorboard_logs \
+    --distributed-config-file /workspace/megatron-lm/examples/gptoss/distributed_config.env \
+  2>&1 | tee "${HOST_TENSORBOARD_LOGS_PATH}/training_mock_$(date +'%y-%m-%d_%H-%M-%S').log"
+```
+**Note:** If you run into issues generating mock data one solution might be to reduce the number of GPUs to 1 and try to generate the data again.
+
+If using real data with with the `HOST_TOKENIZER_MODEL_PATH` and `HOST_DATA_PREFIX` environment variables set, run the following command instead:
+
+```bash
+PYTORCH_IMAGE="nvcr.io/nvidia/pytorch:25.12-py3"
+
+docker run --rm --gpus all --ipc=host --ulimit memlock=-1 \
+  -v "${HOST_MEGATRON_LM_DIR}:/workspace/megatron-lm" \
+  -v "${HOST_CHECKPOINT_PATH}:/workspace/checkpoints" \
+  -v "${HOST_TENSORBOARD_LOGS_PATH}:/workspace/tensorboard_logs" \
+  -v "${HOST_TOKENIZER_MODEL_PATH}:/workspace/tokenizer_model" \
+  -v "$(dirname "${HOST_DATA_PREFIX}"):/workspace/data_dir" \
+  -v "./distributed_config.env:/workspace/megatron-lm/examples/gptoss/distributed_config.env" \
+  --workdir /workspace/megatron-lm \
+  $PYTORCH_IMAGE \
+  bash examples/gptoss/02_train.sh \
+    --checkpoint-path /workspace/checkpoints \
+    --tensorboard-logs-path /workspace/tensorboard_logs \
+    --tokenizer /workspace/tokenizer_model \
+    --data "/workspace/data_dir/$(basename "${HOST_DATA_PREFIX}")" \
+    --distributed-config-file /workspace/megatron-lm/examples/gptoss/distributed_config.env \
+  2>&1 | tee "${HOST_TENSORBOARD_LOGS_PATH}/training_custom_$(date +'%y-%m-%d_%H-%M-%S').log"
+```
+
+## Step 3: Convert Megatron to HuggingFace
+
+Just run the following command to change from the megatron checkpoint from training to the huggingface format to share with others (make sure you have the same virtual environment setup as in Step 0):
+
+```bash
+python3 -m torch.distributed.launch --nproc-per-node=8 examples/gptoss/03_convert_to_hf.py --hf-model openai/gpt-oss-20b --megatron-model ./megatron_checkpoints/openai_gpt-oss_20b
+```

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mamba/.gitignore

@@ -0,0 +1,4 @@
+checkpoints/
+data-cache/
+tensorboard/
+triton-cache/

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mamba/Dockerfile

@@ -0,0 +1,32 @@
+FROM nvcr.io/nvidia/pytorch:24.01-py3
+
+RUN pip uninstall -y triton && \
+    pip install triton==2.1.0 sentencepiece==0.1.99 flask-restful
+
+# The causal-conv1d and mamba-ssm packages below are built from scratch here
+# (which takes significant time) because there are no wheels available on PyPI
+# for these relatively newer versions of the packages that are compatible with
+# the older NGC-variant PyTorch version (e.g. version 2.2.0.dev231106) that we
+# are using (in the NGC base container). Generally, if the package is not
+# compatible with the PyTorch version, then it will generate a Python import
+# error. The package authors tend to only release wheels for new versions of
+# these pacakges which are compatible with the versions of regular PyTorch and
+# NGC-variant PyTorch that are newer at the time of release. So, to use newer
+# versions of these packages with relatively older versions of the NGC PyTorch
+# container, we tend to have to build the packages from scratch.
+
+RUN cd /tmp && \
+    git clone https://github.com/Dao-AILab/causal-conv1d.git && \
+    cd causal-conv1d && \
+    git checkout v1.2.2.post1 && \
+    CAUSAL_CONV1D_FORCE_BUILD=TRUE pip install . && \
+    cd .. && \
+    rm -rf causal-conv1d
+
+RUN cd /tmp && \
+    git clone https://github.com/state-spaces/mamba.git && \
+    cd mamba && \
+    git checkout v2.0.3 && \
+    MAMBA_FORCE_BUILD=TRUE pip install . && \
+    cd .. && \
+    rm -rf mamba

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mamba/README.md

@@ -0,0 +1,117 @@
+# Mamba-based Language Models
+
+## Introduction
+
+This document is an entrypoint into the code used for
+<em>[An Empirical Study of Mamba-based Language Models](https://arxiv.org/abs/2406.07887)</em>.
+
+We are releasing the parameters for some of the models described in that
+technical report via
+[HuggingFace](https://huggingface.co/collections/nvidia/ssms-666a362c5c3bb7e4a6bcfb9c).
+The code in the `main` branch is no longer compatible with the `Mamba2-*`
+checkpoints. You can load them using the
+[fixed snapshot of the code used for the technical report](https://github.com/NVIDIA/Megatron-LM/tree/ssm/examples/mamba).
+
+## Installation
+
+Create and run a Docker container using the [Dockerfile](./Dockerfile).
+
+```
+docker build -t your_image_name:your_tag .
+docker run --gpus all -it --rm \
+  -v /path/to/megatron:/workspace/megatron \
+  -v /path/to/dataset:/workspace/dataset \
+  -v /path/to/checkpoints:/workspace/checkpoints \
+  -w /workspace/megatron/examples/mamba \
+  your_image_name:your_tag
+```
+
+## Train
+
+[`train.sh`](./train.sh) is an example pretraining script, showing how to run on
+a single node. Select between 800M-scale and 8B-scale models by setting the
+`MODEL_SCALE` variable. The 8B-scale hybrid model architecture is the same as
+the one described in the technical report.
+
+## Text Generation
+
+Use [`run_text_gen_server_8b.sh`](./run_text_gen_server_8b.sh) to start a text
+generation server using an 8B hybrid checkpoint. This is configured to run the
+8B hybrid model described in the technical report, with tensor model parallel
+set to 1.
+
+The arguments in the script will need to be changed if using a checkpoint with a
+different model parallel configuration or other differences, such as model
+architecture. For example, to run the 8B pure Mamba-2 model, change
+`--hybrid-layer-pattern` to use only `M` symbols (e.g., 56 `M`s for the 8B
+model), or remove it entirely.
+
+Use [`run_text_gen_server_8b_gpt3.sh`](./run_text_gen_server_8b_gpt3.sh) to start
+a text generation server using the 8B reference Transformer checkpoint.
+
+## Checkpoint Formats
+
+For inference, the model must be configured to match the checkpoint file used,
+including the hybrid layer configuration and model parallel configuration.
+
+If you need to convert a hybrid checkpoint file to a different tensor parallel
+or pipeline parallel size, use
+[the hybrid conversion script](../../tools/checkpoint/hybrid_conversion.py).
+There is an example run command at the end of that file.
+
+Before running that script, you will need to set `PYTHONPATH` to include the
+root directory of your Megatron-LM repository clone.
+
+```
+export PYTHONPATH=<path-to-megatron>:PYTHONPATH
+```
+
+## Hybrid Options
+
+`--hybrid-layer-pattern PATTERN` specifies the layer type for every layer in
+the model using a string of single-character symbols:
+
+* `M` — Mamba layer
+* `*` — Attention layer
+* `-` — MLP layer
+* `E` — MoE layer
+
+The number of layers is derived from the pattern length, so `--num-layers`
+should not be specified when `--hybrid-layer-pattern` is used.
+
+For example, the 8B hybrid model described in the technical report uses:
+
+```
+--hybrid-layer-pattern "M-M-M--M-M*-M-M-M-M--M*-M-M-M-M-M*--M-M-M-M-M*-M--M-M-M-"
+```
+
+This is a 56-layer model with 4 attention layers, 28 MLP layers, and 24 Mamba
+layers.
+
+A pure Mamba model uses only `M` symbols (e.g., `MMMMMMMM` for 8 layers).
+A pure transformer model uses only `*` and `-` symbols.
+
+### Pipeline parallelism
+
+Use `|` to define pipeline stage boundaries for flexible virtual pipeline
+parallelism (fVPP). For example, `M-M-|M-M*-|M-M-|M-M*-` defines 4 pipeline
+segments. The number of segments must be evenly divisible by
+`--pipeline-model-parallel-size`.
+
+### Multi-Token Prediction (MTP)
+
+Use `/` to append MTP layer patterns. Each pattern after the separator
+represents one MTP prediction depth. For example, `M*M*/MM/MM` has main
+pattern `M*M*` with MTP pattern `MM` repeated for 2 depths.
+
+### Deprecated options
+
+`--hybrid-override-pattern`, `--hybrid-attention-ratio`, and
+`--hybrid-mlp-ratio` are deprecated. Use `--hybrid-layer-pattern` instead.
+
+## Mamba vs Mamba-2
+
+This codebase currently only supports Mamba-2, and not the original version of
+Mamba. However, the
+[fixed snapshot of the code used for the technical report](https://github.com/NVIDIA/Megatron-LM/tree/ssm/examples/mamba)
+can be configured to run the original version of Mamba.

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mamba/run_text_gen_server_8b.sh

@@ -0,0 +1,50 @@
+#!/bin/bash
+
+# Use: ./run_text_gen_server_8b.sh <checkpoint-path> <tokenizer-path>
+# To launch the client: python ../../tools/text_generation_cli.py <URL-provided-by-server>
+
+CHECKPOINT_PATH=$1
+TOKENIZER_PATH=$2
+
+HYBRID_LAYER_PATTERN="M-M-M--M-M*-M-M-M-M--M*-M-M-M-M-M*--M-M-M-M-M*-M--M-M-M-"
+
+DISTRIBUTED_ARGS="--nproc_per_node 1 \
+                  --nnodes 1 \
+                  --node_rank 0 \
+                  --master_addr localhost \
+                  --master_port 6000"
+
+export NCCL_IB_SL=1
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_IB_TIMEOUT=19
+export NCCL_IB_QPS_PER_CONNECTION=4
+
+export TRITON_CACHE_DIR="./triton-cache/"
+export TRITON_CACHE_MANAGER="megatron.core.ssm.triton_cache_manager:ParallelFileCacheManager"
+
+torchrun $DISTRIBUTED_ARGS ../../tools/run_mamba_text_generation_server.py \
+       --tensor-model-parallel-size 1  \
+       --pipeline-model-parallel-size 1  \
+       --untie-embeddings-and-output-weights \
+       --hybrid-layer-pattern ${HYBRID_LAYER_PATTERN} \
+       --hidden-size 4096  \
+       --load ${CHECKPOINT_PATH}  \
+       --num-attention-heads 32  \
+       --group-query-attention \
+       --num-query-groups 8 \
+       --attention-dropout 0.0 \
+       --hidden-dropout 0.0 \
+       --disable-bias-linear \
+       --normalization RMSNorm \
+       --seq-length 4096  \
+       --max-position-embeddings 4096  \
+       --position-embedding-type none \
+       --tokenizer-type GPTSentencePieceTokenizer  \
+       --tokenizer-model ${TOKENIZER_PATH} \
+       --distributed-backend nccl \
+       --distributed-timeout-minutes 1440 \
+       --bf16  \
+       --micro-batch-size 1  \
+       --use-mcore-models \
+       --spec megatron.core.models.mamba.mamba_layer_specs mamba_stack_spec \
+       --seed 42

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mamba/run_text_gen_server_8b_gpt3.sh

@@ -0,0 +1,46 @@
+#!/bin/bash
+
+# Use: ./run_text_gen_server_8b_gpt3.sh <checkpoint-path> <tokenizer-path>
+# To launch the client: python ../../tools/text_generation_cli.py <URL-provided-by-server>
+
+CHECKPOINT_PATH=$1
+TOKENIZER_PATH=$2
+
+DISTRIBUTED_ARGS="--nproc_per_node 1 \
+                  --nnodes 1 \
+                  --node_rank 0 \
+                  --master_addr localhost \
+                  --master_port 6000"
+
+export NCCL_IB_SL=1
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_IB_TIMEOUT=19
+export NCCL_IB_QPS_PER_CONNECTION=4
+
+torchrun $DISTRIBUTED_ARGS ../../tools/run_text_generation_server.py \
+       --tensor-model-parallel-size 1  \
+       --pipeline-model-parallel-size 1  \
+       --use-flash-attn \
+       --apply-layernorm-1p \
+       --untie-embeddings-and-output-weights \
+       --num-layers 32  \
+       --hidden-size 4096  \
+       --load ${CHECKPOINT_PATH}  \
+       --num-attention-heads 32  \
+       --attention-dropout 0.0 \
+       --hidden-dropout 0.0 \
+       --disable-bias-linear \
+       --seq-length 4096  \
+       --max-position-embeddings 4096  \
+       --position-embedding-type rope \
+       --rotary-percent 0.5 \
+       --squared-relu \
+       --tokenizer-type GPTSentencePieceTokenizer  \
+       --tokenizer-model ${TOKENIZER_PATH} \
+       --distributed-backend nccl \
+       --distributed-timeout-minutes 1440 \
+       --bf16  \
+       --micro-batch-size 1  \
+       --use-mcore-models \
+       --transformer-impl local \
+       --seed 42

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mamba/train.sh

@@ -0,0 +1,103 @@
+#!/bin/bash
+
+# Use: ./train.sh <data-path> <tokenizer-path>
+
+MODEL_SCALE="800M" # or "8B"
+
+case "${MODEL_SCALE}" in
+    "800M")
+        TENSOR_MODEL_PARALLEL_SIZE=1
+        HYBRID_LAYER_PATTERN="M-M-M--M-*M-M-M-M--*M-M-M-M-*M--M-M-M-*M-M--M-M-"
+        HIDDEN_SIZE=1024
+        NUM_ATTENTION_HEADS=16
+        GLOBAL_BATCH_SIZE=32
+        ;;
+    "8B")
+        TENSOR_MODEL_PARALLEL_SIZE=4
+        HYBRID_LAYER_PATTERN="M-M-M--M-M*-M-M-M-M--M*-M-M-M-M-M*--M-M-M-M-M*-M--M-M-M-"
+        HIDDEN_SIZE=4096
+        NUM_ATTENTION_HEADS=32
+        GLOBAL_BATCH_SIZE=8
+        ;;
+    *)
+        echo "Invalid version specified"
+        exit 1
+        ;;
+esac
+
+DATA_PATH=$1
+TOKENIZER_PATH=$2
+
+export NCCL_IB_SL=1
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_IB_TIMEOUT=19
+export NCCL_IB_QPS_PER_CONNECTION=4
+
+CHECKPOINT_DIR="./checkpoints"
+DATACACHE_DIR="./data-cache"
+TENSORBOARD_DIR="./tensorboard"
+
+mkdir -p ${CHECKPOINT_DIR}
+mkdir -p ${DATACACHE_DIR}
+mkdir -p ${TENSORBOARD_DIR}
+
+export TRITON_CACHE_DIR="./triton-cache/"
+export TRITON_CACHE_MANAGER="megatron.core.ssm.triton_cache_manager:ParallelFileCacheManager"
+
+SEQ_LEN=4096
+TRAIN_SAMPLES=73242188  # 300B tokens / 4096
+LR_WARMUP_SAMPLES=50000
+LR_DECAY_SAMPLES=73192188 # TRAIN_SAMPLES - LR_WARMUP_SAMPLES
+
+options=" \
+       --tensor-model-parallel-size ${TENSOR_MODEL_PARALLEL_SIZE} \
+       --sequence-parallel \
+       --pipeline-model-parallel-size 1 \
+       --use-distributed-optimizer \
+       --overlap-param-gather \
+       --overlap-grad-reduce \
+       --untie-embeddings-and-output-weights \
+       --init-method-std 0.02 \
+       --position-embedding-type none \
+       --hybrid-layer-pattern ${HYBRID_LAYER_PATTERN} \
+       --hidden-size ${HIDDEN_SIZE} \
+       --num-attention-heads ${NUM_ATTENTION_HEADS} \
+       --group-query-attention \
+       --num-query-groups 8 \
+       --seq-length ${SEQ_LEN} \
+       --max-position-embeddings ${SEQ_LEN} \
+       --train-samples ${TRAIN_SAMPLES} \
+       --lr-warmup-samples ${LR_WARMUP_SAMPLES} \
+       --lr-decay-samples ${LR_DECAY_SAMPLES} \
+       --save ${CHECKPOINT_DIR} \
+       --load ${CHECKPOINT_DIR} \
+       --data-path ${DATA_PATH} \
+       --data-cache-path ${DATACACHE_DIR} \
+       --split 99,1,0 \
+       --tokenizer-type GPTSentencePieceTokenizer \
+       --tokenizer-model ${TOKENIZER_PATH} \
+       --distributed-backend nccl \
+       --micro-batch-size 4 \
+       --global-batch-size ${GLOBAL_BATCH_SIZE} \
+       --lr 2.5e-4 \
+       --min-lr 2.5e-5 \
+       --lr-decay-style cosine \
+       --weight-decay 0.1 \
+       --clip-grad 1.0 \
+       --attention-dropout 0.0 \
+       --hidden-dropout 0.0 \
+       --disable-bias-linear \
+       --normalization RMSNorm \
+       --adam-beta1 0.9 \
+       --adam-beta2 0.95 \
+       --log-interval 10 \
+       --save-interval 2000 \
+       --eval-interval 2000 \
+       --eval-iters 32 \
+       --bf16 \
+       --use-mcore-models \
+       --spec megatron.core.models.mamba.mamba_layer_specs mamba_stack_spec \
+       --no-create-attention-mask-in-dataloader \
+       --tensorboard-dir ${TENSORBOARD_DIR}"
+
+torchrun --nproc_per_node 8 ../../pretrain_mamba.py ${options}

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/__init__.py

@@ -0,0 +1 @@
+ 

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/avlm_inference.py

@@ -0,0 +1,244 @@
+import argparse
+import os
+from pathlib import Path
+from typing import Union
+
+# hf path
+import requests
+import torch
+from PIL import Image
+from transformers import AutoProcessor
+from transformers import AutoTokenizer
+import soundfile as sf
+import io
+import numpy as np
+import scipy.signal as signal
+
+from examples.mimo.model_providers.llava_avlm import model_provider_llava_avlm
+from megatron.core import dist_checkpointing, parallel_state, tensor_parallel
+from megatron.core.tensor_parallel.random import model_parallel_cuda_manual_seed
+from megatron.training import print_rank_0
+from examples.mimo.data.utils.calculate_audio_tokens import calculate_num_audio_tokens
+
+def init_distributed(tp_size: int = 1, pp_size: int = 1):
+    if torch.distributed.is_initialized():
+        return
+    rank = int(os.environ.get("LOCAL_RANK", 0))
+    world_size = int(os.environ.get("WORLD_SIZE", 1))
+    torch.cuda.set_device(rank % torch.cuda.device_count())
+    torch.distributed.init_process_group("nccl", rank=rank, world_size=world_size)
+    parallel_state.initialize_model_parallel(tp_size, pp_size)
+
+def get_input_data(
+    processor: AutoProcessor,
+    image_processor: AutoProcessor,
+    audio_processor: AutoProcessor,
+    audio_path: str,
+    image_path: str,
+    prompt: str,
+    device: Union[int, str] = 0):
+    """
+    Prepare inputs for the MIMO model forward pass.
+    """
+
+    def read_audio(audio_path):
+        """Process audio file and return tensor."""
+        with open(audio_path, 'rb') as f:
+            audio_bytes = f.read()
+        audio_io = io.BytesIO(audio_bytes)
+        waveform, sample_rate = sf.read(audio_io)
+        
+        # Resample if needed
+        fixed_sample_rate = 16000
+        if sample_rate != fixed_sample_rate:
+            num_samples = int(len(waveform) * fixed_sample_rate / sample_rate)
+            waveform = signal.resample(waveform, num_samples)
+        
+        # Convert to tensor
+        audio_tensor = torch.from_numpy(waveform).float()
+        return audio_tensor
+
+    def read_image(image_path):
+        """Process image file and return tensor."""
+        with open(image_path, 'rb') as f:
+            image_bytes = f.read()
+        image_io = io.BytesIO(image_bytes)
+        image = Image.open(image_io)
+        image_tensor = torch.from_numpy(np.array(image)).permute(2, 0, 1)  # Convert to CxHxW format
+        image_tensor = image_tensor.float() / 255.0  # rescale to [0,1] range
+        return image_tensor
+
+
+    # read audio and image
+    audio_tensor = read_audio(audio_path)
+    image_tensor = read_image(image_path)
+
+    # set up prompt
+    conversation = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": prompt},
+            ],
+        }
+    ]
+    prompt = processor.apply_chat_template(conversation, add_generation_prompt=True)
+
+    # process audio
+    processed_audios = audio_processor(audio_tensor, sampling_rate=16000)
+    processed_audios = torch.tensor(processed_audios["input_features"])
+    processed_audios = processed_audios.squeeze(0) # remove batch dim
+    num_audio_tokens = calculate_num_audio_tokens(audio_tensor.unsqueeze(0), "openai/whisper-base")
+    audios_seq_lengths = torch.tensor(num_audio_tokens)
+    prompt = prompt.replace("<audio>", "<audio>" * num_audio_tokens)
+
+    # process image
+    processed_images = image_processor(
+        images=image_tensor,
+        return_tensors="pt",
+        do_rescale=False,
+    )["pixel_values"]
+    processed_images = processed_images.squeeze(0) # remove batch dim
+
+    # process prompt
+    processed_prompt_inputs = processor(
+        images=image_tensor,
+        text=prompt,
+        add_special_tokens=False,
+        return_tensors="pt",
+        do_rescale=False,
+    )
+
+    # set batch data
+    processed_images = processed_images.unsqueeze(0).to(device)
+    processed_audios = processed_audios.unsqueeze(0).to(device)
+    audios_seq_lengths = audios_seq_lengths.unsqueeze(0).to(device)
+    tokens = processed_prompt_inputs["input_ids"].to(device)
+    modality_inputs = {
+        "images": {"clip_encoder": {"pixel_values": processed_images}},
+        "audios": {"whisper_encoder": {"input_features": processed_audios, "seq_lengths": audios_seq_lengths}}
+    }
+    batch_data = {
+        "tokens": tokens,
+        "modality_inputs": modality_inputs,
+    }
+
+    return batch_data
+
+
+def main():
+    parser = argparse.ArgumentParser("Test loading a distributed LLaVA checkpoint")
+    parser.add_argument("--ckpt", required=False, help="Path to checkpoint optional")
+    parser.add_argument("--tp", type=int, default=1, help="Tensor parallel size")
+    parser.add_argument("--pp", type=int, default=1, help="Pipeline parallel size")
+    parser.add_argument("--audio-path", type=str,required=True, help="Path to audio file")
+    parser.add_argument("--image-path", type=str,required=True, help="Path to image file")
+    parser.add_argument("--prompt", type=str,required=True, help="Prompt")
+    args = parser.parse_args()
+
+
+    init_distributed(args.tp, args.pp)
+    model_parallel_cuda_manual_seed(123)
+
+    device = torch.device("cuda")
+
+    model = model_provider_llava_avlm().to(device)
+
+    # Load distributed checkpoint if provided.
+    if args.ckpt:
+        load_distributed_checkpoint(model, args.ckpt)
+
+    # set tokenizer
+    tokenizer = AutoTokenizer.from_pretrained("llava-hf/llava-1.5-7b-hf")
+    tokenizer.add_special_tokens({'additional_special_tokens': ["<audio>"]})
+    tokenizer.vocab["<audio>"] = 32002
+    tokenizer.added_tokens_encoder["<audio>"] = 32002
+    tokenizer.added_tokens_decoder[32002] = "<audio>"
+
+    # set processors
+    processor = AutoProcessor.from_pretrained("llava-hf/llava-1.5-7b-hf")
+    processor.tokenizer = tokenizer
+    image_processor = AutoProcessor.from_pretrained("llava-hf/llava-1.5-7b-hf").image_processor
+    audio_processor = AutoProcessor.from_pretrained("openai/whisper-base")
+    
+    
+    data = get_input_data(
+        processor,
+        image_processor,
+        audio_processor,
+        args.audio_path,
+        args.image_path,
+        args.prompt,
+        device=device)
+
+    # ------------------------------------------------------------------
+    # Greedy generation
+    # ------------------------------------------------------------------
+    max_new_tokens = 128
+    model.eval()    
+
+    tokens = data["tokens"]
+
+    with torch.no_grad():
+        for _ in range(max_new_tokens):
+            seq_len = tokens.size(1)
+            position_ids = torch.arange(seq_len, device=tokens.device).unsqueeze(0)
+            logits, _ = model(
+                input_ids=tokens,
+                position_ids=position_ids,
+                attention_mask=None,
+                modality_inputs=data["modality_inputs"],
+            )
+            
+            # All-gather logits across tensor parallel ranks
+            # logits shape: [batch, seq, vocab_parallel_size]
+            gathered_logits = tensor_parallel.gather_from_tensor_model_parallel_region(logits)
+
+            # The language model returns logits in [batch, seq, vocab] format.
+            next_token_logits = gathered_logits[:, -1, :]
+            next_token = torch.argmax(next_token_logits, dim=-1, keepdim=True)
+
+            tokens = torch.cat([tokens, next_token], dim=1)
+
+            if processor.tokenizer.eos_token_id is not None and next_token.item() == processor.tokenizer.eos_token_id:
+                break
+
+    # Only decode and print on rank 0
+    if torch.distributed.get_rank() == 0:
+        generated_text = processor.tokenizer.decode(tokens[0], skip_special_tokens=True)
+        print("\n=== Generated text ===\n")
+        print(generated_text)
+
+
+def load_distributed_checkpoint(model: torch.nn.Module, ckpt_dir: str):
+    """Load a MIMO model from a Megatron distributed checkpoint directory"""
+
+    if not os.path.isdir(ckpt_dir):
+        raise FileNotFoundError(f"Checkpoint directory does not exist: {ckpt_dir}")
+
+
+    template_sd = {"model": model.sharded_state_dict()}
+
+    loaded_sd = dist_checkpointing.load(template_sd, ckpt_dir)
+
+    model_state_dict = loaded_sd["model"]
+    incompat = model.load_state_dict(model_state_dict, strict=False)
+
+    missing = [k for k in incompat.missing_keys if "extra_state" not in k]
+    unexpected = [k for k in incompat.unexpected_keys if "extra_state" not in k]
+    if missing or unexpected:
+        print_rank_0(
+            f"[Rank {torch.distributed.get_rank() if torch.distributed.is_initialized() else 0}] "
+            f"Checkpoint loaded with mismatches. Missing: {missing}, Unexpected: {unexpected}"
+        )
+
+    print_rank_0(
+        f"[Rank {torch.distributed.get_rank() if torch.distributed.is_initialized() else 0}] "
+        f"Successfully loaded checkpoint from {ckpt_dir}"
+    )
+
+    return model
+
+
+if __name__ == "__main__":
+    main()

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/configs/llava_avlm.py

@@ -0,0 +1,59 @@
+# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+
+"""
+Configuration utilities for the MIMO implementation of the LLaVA AVLM.
+"""
+
+
+from typing import Optional
+
+import torch
+
+from megatron.core.extensions.transformer_engine import (
+    TEColumnParallelLinear,
+    TERowParallelLinear,
+)
+from megatron.core.models.gpt.gpt_layer_specs import (
+    get_gpt_layer_with_transformer_engine_spec,
+)
+from megatron.core.transformer.mlp import MLP, MLPSubmodules
+from megatron.core.transformer.spec_utils import ModuleSpec
+from megatron.core.transformer.transformer_config import TransformerConfig
+from examples.mimo.configs.llava_vlm import get_vicuna_language_model_config
+
+
+def get_llava_projection_config( 
+    hidden_size: int = 4096,
+    config: Optional[TransformerConfig] = None,
+) -> TransformerConfig:
+    """Return a TransformerConfig for the vision projection MLP."""
+
+    cfg = TransformerConfig(num_layers=1, hidden_size=hidden_size, num_attention_heads=1)
+    cfg.ffn_hidden_size = 4096
+    cfg.bias_activation_fusion = True
+    cfg.add_bias_linear = True
+    cfg.activation_func = torch.nn.functional.gelu
+
+    # Allow caller overrides.
+    if config is not None:
+        for field, value in vars(config).items():
+            setattr(cfg, field, value)
+
+    return cfg
+
+
+
+def get_vicuna_language_layer_spec() -> ModuleSpec:
+    """Layer spec for the language model (Transformer-Engine GPT block)."""
+    return get_gpt_layer_with_transformer_engine_spec()
+
+def get_llava_projection_layer_spec() -> ModuleSpec:
+    """Layer spec for the vision-projection MLP."""
+
+    return ModuleSpec(
+        module=MLP,
+        submodules=MLPSubmodules(
+            linear_fc1=TEColumnParallelLinear,
+            linear_fc2=TERowParallelLinear,
+        ),
+    )

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/configs/llava_vlm.py

@@ -0,0 +1,116 @@
+# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+
+"""
+Configuration utilities for the MIMO implementation of the LLaVA VLM.
+"""
+
+
+from typing import Optional
+
+import torch
+
+from megatron.core.extensions.transformer_engine import (
+    TEColumnParallelLinear,
+    TERowParallelLinear,
+)
+from megatron.core.models.gpt.gpt_layer_specs import (
+    get_gpt_layer_with_transformer_engine_spec,
+)
+from megatron.core.transformer.mlp import MLP, MLPSubmodules
+from megatron.core.transformer.spec_utils import ModuleSpec
+from megatron.core.transformer.transformer_config import TransformerConfig
+
+
+def get_vicuna_language_model_config(  
+    config: Optional[TransformerConfig] = None,
+) -> TransformerConfig:
+    """Return a TransformerConfig tuned for **Vicuna-7B**.
+
+    The hyper-parameters follow the published Vicuna-7B weights (same sizes as
+    Llama-7B).
+    """
+
+    cfg = TransformerConfig(num_layers=32, hidden_size=4096, num_attention_heads=32)
+
+    # Feed-forward / MLP hidden size (11008 in original Vicuna).
+    cfg.ffn_hidden_size = 11008
+
+    # SwiGLU (SiLU-gate) activation.
+    cfg.activation_func = torch.nn.functional.silu
+    cfg.gated_linear_unit = True
+
+    # Normalisation – RMSNorm
+    cfg.normalization = "RMSNorm"
+    cfg.rms_norm_eps = 1e-5
+
+    # Positional embeddings – RoPE.
+    cfg.position_embedding_type = "rope"
+    cfg.rotary_base = 10000
+    cfg.rotary_percent = 1.0
+
+    # Sequence length.
+    cfg.seq_length = 4096
+    cfg.max_position_embeddings = 4096
+
+    # Attention / dropout.
+    cfg.attention_dropout = 0.0
+    cfg.hidden_dropout = 0.0
+
+    # GQA disabled (queries == heads).
+    cfg.num_query_groups = 32
+
+    # Bias usage.
+    cfg.add_bias_linear = False
+
+    # Weight sharing.
+    cfg.untie_embeddings_and_output_weights = False
+
+    # Kernel / TE fusions.
+    cfg.bias_activation_fusion = True
+    cfg.masked_softmax_fusion = True
+    cfg.persist_layer_norm = True
+    cfg.bias_dropout_fusion = True
+    cfg.apply_rope_fusion = True
+
+    # Apply user overrides last.
+    if config is not None:
+        for field, value in vars(config).items():
+            setattr(cfg, field, value)
+
+    return cfg
+
+def get_llava_projection_config( 
+    hidden_size: int = 4096,
+    config: Optional[TransformerConfig] = None,
+) -> TransformerConfig:
+    """Return a TransformerConfig for the vision projection MLP."""
+
+    cfg = TransformerConfig(num_layers=1, hidden_size=hidden_size, num_attention_heads=1)
+    cfg.ffn_hidden_size = 4096
+    cfg.bias_activation_fusion = True
+    cfg.add_bias_linear = True
+    cfg.activation_func = torch.nn.functional.gelu
+
+    # Allow caller overrides.
+    if config is not None:
+        for field, value in vars(config).items():
+            setattr(cfg, field, value)
+
+    return cfg
+
+
+
+def get_vicuna_language_layer_spec() -> ModuleSpec:
+    """Layer spec for the language model (Transformer-Engine GPT block)."""
+    return get_gpt_layer_with_transformer_engine_spec()
+
+def get_llava_projection_layer_spec() -> ModuleSpec:
+    """Layer spec for the vision-projection MLP."""
+
+    return ModuleSpec(
+        module=MLP,
+        submodules=MLPSubmodules(
+            linear_fc1=TEColumnParallelLinear,
+            linear_fc2=TERowParallelLinear,
+        ),
+    )

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/configs/mock.py

@@ -0,0 +1,130 @@
+# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+
+"""
+Mock configuration utilities for MIMO model with vision encoder.
+
+This module provides functions to create test configurations for:
+1. Language model (based on LLaMA architecture)
+2. Vision encoder (based on CLIP ViT)
+3. Vision projection (MLP)
+
+These configurations are intended for testing and development purposes only.
+"""
+
+from typing import Optional
+
+from megatron.core.extensions.transformer_engine import (
+    TEColumnParallelLinear,
+    TERowParallelLinear,
+)
+from megatron.core.models.gpt.gpt_layer_specs import (
+    get_gpt_layer_with_transformer_engine_spec,
+)
+from megatron.core.transformer.mlp import MLP, MLPSubmodules
+from megatron.core.transformer.spec_utils import ModuleSpec
+from megatron.core.transformer.transformer_config import TransformerConfig
+
+
+def get_mock_language_model_config(config: Optional[TransformerConfig] = None) -> TransformerConfig:
+    """
+    Create a mock language model configuration.
+
+    Args:
+        config: Optional base configuration to modify
+
+    Returns:
+        TransformerConfig: Mock configuration for a language model
+    """
+
+    config = TransformerConfig(num_layers=1, hidden_size=128, num_attention_heads=4)
+
+    if config is not None:
+        for field_name, field_value in vars(config).items():
+            setattr(config, field_name, field_value)
+
+    return config
+
+def get_mock_vision_model_config(config: Optional[TransformerConfig] = None) -> TransformerConfig:
+    """
+    Create a mock vision model configuration.
+
+    Args:
+        config: Optional base configuration to modify
+
+    Returns:
+        TransformerConfig: Mock configuration for a vision model
+    """
+    config = TransformerConfig(num_layers=1, hidden_size=128, num_attention_heads=4)
+
+    config.add_bias_linear = True
+    config.add_qkv_bias = True
+    config.hidden_dropout = 0.0
+    config.attention_dropout = 0.0
+    config.ffn_hidden_size = config.hidden_size * 4
+    config.gated_linear_unit = False
+    config.kv_channels = 64
+    config.layernorm_zero_centered_gamma = False
+    config.apply_query_key_layer_scaling = False
+    config.bias_activation_fusion = False
+    config.bias_dropout_fusion = False
+    config.attention_softmax_in_fp32 = True
+    config.normalization = 'LayerNorm'
+    config.apply_rope_fusion = False
+    return config
+
+
+def get_mock_projection_config(hidden_size: int = 128) -> TransformerConfig:
+    """
+    Create a mock projection layer configuration.
+
+    Args:
+        hidden_size: Hidden dimension size (used as the vision projection output size)
+
+    Returns:
+        TransformerConfig: Mock configuration for a projection layer
+    """
+    config = TransformerConfig(num_layers=1, hidden_size=hidden_size, num_attention_heads=1)
+
+    config.ffn_hidden_size = hidden_size * 4
+    config.gated_linear_unit = False
+    config.bias_activation_fusion = False
+    config.add_bias_linear = False
+    config.normalization = 'LayerNorm'
+
+    return config
+
+
+def get_mock_language_layer_spec():
+    """
+    Get the mock layer specification for the language model.
+
+    Returns:
+        ModuleSpec: Mock specification for language model layers
+    """
+    return get_gpt_layer_with_transformer_engine_spec()
+
+
+def get_mock_vision_layer_spec():
+    """
+    Get the mock layer specification for the vision model.
+
+    Args:
+        normalization: Type of normalization to use
+
+    Returns:
+        ModuleSpec: Mock specification for vision model layers
+    """
+    return get_gpt_layer_with_transformer_engine_spec()
+
+
+def get_mock_projection_layer_spec():
+    """
+    Get the mock layer specification for the projection layer.
+
+    Returns:
+        ModuleSpec: Mock specification for projection layers
+    """
+    return ModuleSpec(
+        module=MLP,
+        submodules=MLPSubmodules(linear_fc1=TEColumnParallelLinear, linear_fc2=TERowParallelLinear),
+    )

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/data/__init__.py

@@ -0,0 +1,5 @@
+from .energon_avlm_task_encoder import VisionAudioQASample
+
+all = [
+    VisionAudioQASample,
+]

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/data/avlm_sample_loader.py

@@ -0,0 +1,86 @@
+import io
+
+def sample_loader(raw: dict) -> dict:
+    """
+    Load the sample from the raw data.
+    Example content of wds data:
+        - Example of wds data
+            100_100.img
+            100_100.json
+            100_100.synthesized_683016ff-bb67-4a12-a873-a7e5d4132903.wav.flac
+            100_100.synthesized_6a7b3a1c-05a9-4720-b7e6-f7028415dc71.wav.flac
+            100_100.synthesized_7c4b39ba-20ef-4319-bd94-291c94ad362a.wav.flac
+            100_100.synthesized_932f067b-2b9a-425d-b8e6-f74ca83335a2.wav.flac
+            Content of 100_100.json: 
+                {
+                    "num_image": 7,
+                    "length": 2049,
+                    "label_length": 157,
+                    "conversations": [
+                        {
+                            "from": "human",
+                            "value": "<image><audio>"
+                        },
+                        {
+                            "from": "gpt",
+                            "value": "The stop sign is red, while the one-way signs are typically black and white."
+                        },
+                        ...
+                        {
+                            "from": "human",
+                            "value": "<audio>"
+                        },
+                        {
+                            "from": "gpt",
+                            "value": "The purpose of these street signs is to communicate..."
+                        }
+                    ],
+                    "audios": [
+                        "100_100.synthesized_6a7b3a1c-05a9-4720-b7e6-f7028415dc71.wav.flac",
+                        "100_100.synthesized_932f067b-2b9a-425d-b8e6-f74ca83335a2.wav.flac",
+                        "100_100.synthesized_7c4b39ba-20ef-4319-bd94-291c94ad362a.wav.flac",
+                        "100_100.synthesized_683016ff-bb67-4a12-a873-a7e5d4132903.wav.flac"
+                    ],
+                    "images": [
+                        "100_100.img"
+                    ]
+                }
+        - Example of read raw data for Energon
+            raw["json"] -> json content
+            raw["img"] -> bytes image content
+            raw["synthesized_6a7b3a1c-05a9-4720-b7e6-f7028415dc71.wav.flac"] -> bytes audio content
+            raw["synthesized_932f067b-2b9a-425d-b8e6-f74ca83335a2.wav.flac"] -> bytes audio content
+            raw["synthesized_683016ff-bb67-4a12-a873-a7e5d4132903.wav.flac"] -> bytes audio content
+    """
+
+    jsn_content = raw["json"]
+    conversation = jsn_content["conversations"]
+    
+    # Get raw image bytes
+    image_bytes = raw["img"]
+
+    # Get raw audio bytes
+    audio_names = [audio_name.split('.', 1)[1] for audio_name in jsn_content["audios"]] # example of audio_name file: "100_100.synthesized_683016ff-bb67-4a12-a873-a7e5d4132903.wav.flac" -> "synthesized_683016ff-bb67-4a12-a873-a7e5d4132903.wav"
+    audio_name = audio_names[0]  # for now, take only the first audio
+    audio_bytes = raw[audio_name]
+
+    # process conversation, take only the first turn
+    context = conversation[0]["value"]
+    answers = conversation[1]["value"]
+
+    # check that context only contains one "<audio>"
+    # if contains more than one, replace all occurrences with a single one
+    if context.count("<audio>") > 1:
+        parts = context.split("<audio>")
+        context = parts[0] + "<audio>" + "".join(parts[1:])
+
+    return dict(
+        __key__=raw["__key__"],
+        context=context,
+        answers=answers,
+        image=image_bytes,
+        audio=audio_bytes,
+    )
+
+def part_filter(part: str) -> bool:
+    return True

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/data/energon_avlm_task_encoder.py

@@ -0,0 +1,484 @@
+# Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+
+import argparse
+import logging
+import os
+import sys
+from dataclasses import dataclass
+from enum import Enum
+from typing import Dict, List, Protocol, Union
+
+import torch
+import torch.nn.utils.rnn as rnn_utils
+from PIL import Image
+import numpy as np
+import soundfile as sf
+from scipy import signal
+import io
+from megatron.training.global_vars import get_tokenizer
+
+sys.path.append(
+    os.path.abspath(
+        os.path.join(
+            os.path.dirname(__file__),
+            os.path.pardir,
+            os.path.pardir,
+            os.path.pardir,
+            "examples/multimodal",
+        )
+    )
+)
+from dataloader_provider import train_valid_test_dataloaders_provider
+from transformers import AutoProcessor
+from examples.mimo.data.utils.calculate_audio_tokens import calculate_num_audio_tokens
+
+from megatron.energon import (
+    DefaultTaskEncoder,
+    VQASample,
+    WorkerConfig,
+    get_loader,
+    get_train_dataset,
+)
+from megatron.energon.task_encoder.base import stateless
+from megatron.training import get_args
+
+IMAGE_TOKEN = "<image>"
+AUDIO_TOKEN = "<audio>"
+
+
+@dataclass
+class ConversationTemplateConfig:
+    system: str = None
+    chat_template: str = None
+
+
+@dataclass
+class LlavaConversationTemplateConfig(ConversationTemplateConfig):
+    """Default system prompt and chat template for Llava training."""
+
+    system: str = None
+    chat_template: str = None
+
+
+@dataclass
+class VisionAudioQASample(VQASample):
+    """
+    Sample type for vision audio question answering.
+    Adding audio to the VQASample class.
+    """
+
+    #: The input audio tensor in the shape
+    audio: torch.Tensor = None
+
+
+class AVLMModelType(Enum):
+    IMAGE_AUDIO_LLAVA_AVLM = "image_audio_llava_avlm"
+
+
+class AVLMTaskEncoder(
+    DefaultTaskEncoder[
+        VisionAudioQASample,
+        dict,
+        dict,
+        dict,
+    ]
+):
+    def __init__(
+        self,
+        model_type: AVLMModelType,
+        processor,
+        image_processor,
+        audio_processor,
+        conversation_template_config=None,
+    ):
+        self.model_type = model_type
+        self.processor = processor
+        self.image_processor = image_processor
+        self.audio_processor = audio_processor
+        self.conversation_template_config = conversation_template_config
+
+    def apply_prompt_template(self, input_text: VisionAudioQASample):
+        """Create conversation prompt string using HF chat template.
+
+        The first user turn always contains an image placeholder, later turns are text-only.
+        Returns a *prompt string* that can be fed into the processor together with an image.
+        """
+
+        user_msgs = input_text.context
+        bot_msgs = input_text.answers
+
+        def _ensure_list_type(value):
+            if isinstance(value, list):
+                return value
+            return [value]
+
+        user_msgs = _ensure_list_type(user_msgs)
+        bot_msgs = _ensure_list_type(bot_msgs)
+
+        conversation = []
+        for _, (u_txt, b_txt) in enumerate(zip(user_msgs, bot_msgs)):
+            conversation.append(
+                {
+                    "role": "user",
+                    "content": [{"type": "text", "text": u_txt}],
+                }
+            )
+            conversation.append(
+                {
+                    "role": "assistant",
+                    "content": [{"type": "text", "text": b_txt}],
+                }
+            )
+
+        # Inject optional system message
+        if (
+            self.conversation_template_config
+            and self.conversation_template_config.system
+        ):
+            conversation.insert(
+                0,
+                {"role": "system", "content": self.conversation_template_config.system},
+            )
+
+        # Select chat template
+        if (
+            self.conversation_template_config
+            and self.conversation_template_config.chat_template
+        ):
+            self.processor.chat_template = (
+                self.conversation_template_config.chat_template
+            )
+        return self.processor.apply_chat_template(
+            conversation,
+            tokenize=False,
+            add_generation_prompt=False,
+        )
+
+    def _find_pattern_indices(
+        self, template, pattern, start_idx=0, allow_first_mismatch=False
+    ):
+        template_len = len(template)
+        pat_len = len(pattern)
+        for i in range(start_idx, template_len - pat_len + 1):
+            match = template[i : i + pat_len] == pattern
+            if torch.all(match) or (allow_first_mismatch and torch.all(match[1:])):
+                return i, i + pat_len
+        return -1, -1
+
+    @stateless
+    def encode_sample(self, sample: VisionAudioQASample):
+        """Return tokenised multimodal sample."""
+        args = get_args()
+        prompt = self.apply_prompt_template(sample)
+        logging.debug(f"prompt: {prompt}")
+
+        # Convert raw image bytes to tensor
+        if sample.image is not None:
+            image_io = io.BytesIO(sample.image)
+            image = Image.open(image_io)
+            image_tensor = torch.from_numpy(np.array(image)).permute(2, 0, 1)  # Convert to CxHxW format
+            image_tensor = image_tensor.float() / 255.0  # rescale to [0,1] range
+        else:
+            image_tensor = None
+
+        # Convert raw audio data to tensor
+        if sample.audio is not None:
+            audio_io = io.BytesIO(sample.audio)
+            # Read audio first
+            waveform, sample_rate = sf.read(audio_io)
+            # Resample if needed
+            fixed_sample_rate = 16000
+            if sample_rate != fixed_sample_rate:
+                # Calculate number of samples for 16kHz
+                num_samples = int(len(waveform) * fixed_sample_rate / sample_rate)
+                # Resample using scipy's resample
+                waveform = signal.resample(waveform, num_samples)
+            # Convert to tensor
+            audio_tensor = torch.from_numpy(waveform).float()
+        else:
+            audio_tensor = None
+
+        # Process audio + prompt
+        # Here, we:
+        #  + process the audio
+        #  + manually calculate the number of audio tokens, then add them to the prompt
+        if audio_tensor is not None:
+            processed_audios = self.audio_processor(audio_tensor, sampling_rate=fixed_sample_rate)
+            processed_audios = torch.tensor(processed_audios["input_features"])
+            processed_audios = processed_audios.squeeze(0)  # remove batch dim
+            num_audio_tokens = calculate_num_audio_tokens(audio_tensor.unsqueeze(0), args.audio_encoder_model)
+            audios_seq_lengths = torch.tensor(num_audio_tokens)
+            processed_prompt = prompt.replace(AUDIO_TOKEN, AUDIO_TOKEN * num_audio_tokens)
+        else:
+            processed_audios = None
+            audios_seq_lengths = None
+            processed_prompt = prompt
+
+        # Process image + prompt
+        # Here, we:
+        #  + process the image
+        #  + use self.processor to automatically calculate the number  
+        #    of image tokens, then add them to the prompt
+        #    => this step combine adding the corresponding image tokens to the prompt AND
+        #       tokenize the prompt after that
+        if image_tensor is not None:
+            processed_images = self.image_processor(
+                images=image_tensor,
+                return_tensors="pt",
+                do_rescale=False,
+            )["pixel_values"]
+            processed_images = processed_images.squeeze(0)  # remove batch dim
+        else:
+            processed_images = None
+
+        processed_prompt_inputs = self.processor(
+            images=image_tensor,
+            text=processed_prompt,
+            add_special_tokens=False,
+            return_tensors="pt",
+            do_rescale=False,
+        )
+        
+        # Remove batch dim
+        for k, v in processed_prompt_inputs.items():
+            processed_prompt_inputs[k] = v.squeeze(0)
+
+        # Combine image and audio processed data
+        inputs = {
+            "input_ids": processed_prompt_inputs["input_ids"],
+            "attention_mask": processed_prompt_inputs["attention_mask"],
+        }
+
+        if processed_images is not None:
+            inputs["images"] = processed_images
+
+        if processed_audios is not None:
+            inputs["audios"] = processed_audios
+            inputs["audios_seq_lengths"] = audios_seq_lengths
+
+        answers = sample.answers
+        if answers:
+            if not isinstance(answers, list):
+                answers = [answers]
+            tokenizer = self.processor.tokenizer
+            inputs["labels"] = torch.full_like(inputs["input_ids"], fill_value=-100)
+            search_idx = 0
+            for ans in answers:
+                answer_tokens = tokenizer.encode(
+                    ans, add_special_tokens=False, return_tensors="pt"
+                )[0]
+                s_idx, e_idx = self._find_pattern_indices(
+                    inputs["input_ids"], answer_tokens, search_idx
+                )
+                if s_idx == -1:
+                    raise ValueError(f"Answer not found in input_ids: {ans}")
+                inputs["labels"][s_idx:e_idx] = inputs["input_ids"][s_idx:e_idx]
+                search_idx = e_idx
+
+            # shift inputs and labels by 1
+            inputs["input_ids"] = inputs["input_ids"][:-1]
+            inputs["labels"] = inputs["labels"][1:]
+            inputs["loss_mask"] = (inputs["labels"] != -100).long()
+
+        else:
+            inputs["labels"] = None
+            inputs["loss_mask"] = None
+
+        return inputs
+
+    def batch(self, samples: List[Dict]) -> Dict:
+        """Pad/stack individual samples into a single batch dict."""
+
+        if not samples:
+            return {}
+
+        batched: Dict[str, torch.Tensor] = {}
+        keys = samples[0].keys()
+
+        for key in keys:
+            values = [s[key] for s in samples if key in s and s[key] is not None]
+
+            processor = KEY_PROCESSORS.get(key)
+            if processor is not None:
+                batched[key] = processor(values)
+                continue
+
+            # Fallback behaviours if no specific processor is registered.
+            if isinstance(values[0], torch.Tensor):
+                batched[key] = torch.stack(values, dim=0)
+            else:
+                batched[key] = values
+
+        return batched
+
+    def encode_batch_avlm_clip_whisper_llava(self, batch_data: Dict) -> Dict:
+        input_ids = batch_data["input_ids"]
+        labels = batch_data.get("labels")
+        loss_mask = batch_data.get("loss_mask")
+
+        seq_len = input_ids.size(1)
+        position_ids = torch.arange(seq_len, dtype=torch.long, device=input_ids.device)
+        position_ids = position_ids.unsqueeze(0).repeat(input_ids.size(0), 1)
+
+        images = batch_data.get("images")
+        audios = batch_data.get("audios")
+        audios_seq_lengths = batch_data.get("audios_seq_lengths")
+
+        output = {
+            "input_ids": input_ids,
+            "labels": labels,
+            "loss_mask": loss_mask,
+            "position_ids": position_ids,
+        }
+
+        if images is not None:
+            output["modality_inputs"] = {
+                "images": {"clip_encoder": {"pixel_values": images}}
+            }
+
+        if audios is not None:
+            if "modality_inputs" not in output:
+                output["modality_inputs"] = {}
+            output["modality_inputs"]["audios"] = {
+                "whisper_encoder": {
+                    "input_features": audios,
+                    "seq_lengths": audios_seq_lengths
+                }
+            }
+
+        return output
+
+    def encode_batch(self, batch_data: Dict) -> dict:
+        if self.model_type is AVLMModelType.IMAGE_AUDIO_LLAVA_AVLM:
+            return self.encode_batch_avlm_clip_whisper_llava(batch_data)
+        else:
+            raise ValueError(f"Model type {self.model_type} not supported")
+
+
+def llava_avlm_dataloader_provider(train_val_test_num_samples):
+    args = get_args()
+
+    # update global tokenizer if hf_assign_unused_tokens is set
+    if args.hf_assign_unused_tokens:
+        _tokenizer = get_tokenizer()._tokenizer
+        for token_id_pair in args.hf_assign_unused_tokens:
+            token, id_str = token_id_pair.split(',')
+            id = int(id_str)
+            _tokenizer.add_special_tokens({'additional_special_tokens': [token]})
+            _tokenizer.vocab[token] = id
+            _tokenizer.added_tokens_encoder[token] = id
+            _tokenizer.added_tokens_decoder[id] = token
+        get_tokenizer()._tokenizer = _tokenizer
+
+    tokenizer_model_id = args.tokenizer_model
+    processor = AutoProcessor.from_pretrained(tokenizer_model_id)
+    processor.tokenizer = get_tokenizer()._tokenizer  # update processor to use custom tokenizer
+    image_processor = AutoProcessor.from_pretrained(tokenizer_model_id).image_processor
+    audio_processor = AutoProcessor.from_pretrained(args.audio_encoder_model)
+
+    return train_valid_test_dataloaders_provider(
+        train_val_test_num_samples,
+        task_encoder=AVLMTaskEncoder(
+            model_type=AVLMModelType.IMAGE_AUDIO_LLAVA_AVLM,
+            processor=processor,
+            image_processor=image_processor,
+            audio_processor=audio_processor,
+            conversation_template_config=LlavaConversationTemplateConfig(),
+        ),
+    )
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--data_path",
+        type=str,
+        required=True,
+        help="path to the dataset directory in energon format",
+    )
+    args = parser.parse_args()
+    
+    # for image audio llava avlm
+    hf_model_id = "llava-hf/llava-1.5-7b-hf"
+    model_type = AVLMModelType.IMAGE_AUDIO_LLAVA_AVLM
+
+    processor = AutoProcessor.from_pretrained(hf_model_id)
+    processor.tokenizer = get_tokenizer()._tokenizer
+    image_processor = AutoProcessor.from_pretrained(hf_model_id).image_processor
+    audio_processor = AutoProcessor.from_pretrained("openai/whisper-small")
+
+    worker_config = WorkerConfig.default_worker_config(0)
+    train_loader = get_loader(
+        get_train_dataset(
+            args.data_path,
+            batch_size=8,
+            shuffle_buffer_size=None,
+            max_samples_per_sequence=None,
+            task_encoder=AVLMTaskEncoder(
+                model_type=model_type,
+                processor=processor,
+                image_processor=image_processor,
+                audio_processor=audio_processor,
+                conversation_template_config=LlavaConversationTemplateConfig(),
+            ),
+            worker_config=worker_config,
+        ),
+        worker_config=worker_config,
+    )
+
+    print(f"data loader length {len(train_loader)}")
+    for index, each_batch in enumerate(train_loader):
+        print(f"batch index {index} tokens {each_batch['input_ids']}")
+        if 'modality_inputs' in each_batch:
+            if 'images' in each_batch['modality_inputs']:
+                print(f"images shape: {each_batch['modality_inputs']['images']['clip_encoder']['pixel_values'].shape}")
+            if 'audios' in each_batch['modality_inputs']:
+                print(f"audios shape: {each_batch['modality_inputs']['audios']['whisper_encoder']['input_features'].shape}")
+        break
+
+
+# -----------------------------------------------------------------------------
+# Key processing utilities for batching
+# -----------------------------------------------------------------------------
+
+
+class KeyProcessor(Protocol):
+    """Callable that aggregates a list of tensors into a single batched tensor."""
+
+    def __call__(self, values: List[torch.Tensor]) -> torch.Tensor:  # pragma: no cover
+        ...
+
+
+class StackProcessor:
+    """Simply stack tensors along a given dimension."""
+
+    def __init__(self, dim: int = 0):
+        self.dim = dim
+
+    def __call__(self, values: List[torch.Tensor]) -> torch.Tensor:
+        return torch.stack(values, dim=self.dim)
+
+
+class PaddingProcessor:
+    """Pad variable-length sequences to the same length."""
+
+    def __init__(self, pad_value: int, batch_first: bool = True):
+        self.pad_value = pad_value
+        self.batch_first = batch_first
+
+    def __call__(self, values: List[torch.Tensor]) -> torch.Tensor:
+        return rnn_utils.pad_sequence(
+            values, batch_first=self.batch_first, padding_value=self.pad_value
+        )
+
+
+# Registry mapping sample keys to their corresponding processor.
+KEY_PROCESSORS: Dict[str, KeyProcessor] = {
+    "images": StackProcessor(),
+    "audios": StackProcessor(),
+    "audios_seq_lengths": StackProcessor(),
+    "input_ids": PaddingProcessor(pad_value=0),
+    "attention_mask": PaddingProcessor(pad_value=0),
+    "loss_mask": PaddingProcessor(pad_value=0),
+    "labels": PaddingProcessor(pad_value=-100),
+} 

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/data/energon_vlm_task_encoder.py

@@ -0,0 +1,654 @@
+# Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+
+import argparse
+import logging
+import os
+import sys
+from dataclasses import dataclass
+from enum import Enum
+from typing import Dict, List, Union, Iterable, Tuple, Optional, Protocol
+import heapq
+import torch
+import torch.nn.utils.rnn as rnn_utils
+
+# TODO: ykarnati, use absolute import or 
+# define train_valid_test_dataloaders_provider in here
+sys.path.append(
+    os.path.abspath(
+        os.path.join(
+            os.path.dirname(__file__),
+            os.path.pardir,
+            os.path.pardir,
+            os.path.pardir,
+            "examples/multimodal",
+        )
+    )
+)
+from dataloader_provider import train_valid_test_dataloaders_provider
+from transformers import AutoProcessor
+
+from megatron.core.packed_seq_params import PackedSeqParams
+from megatron.energon import (
+    DefaultTaskEncoder,
+    VQASample,
+    WorkerConfig,
+    get_loader,
+    get_train_dataset,
+)
+from megatron.energon.task_encoder.base import stateless
+from megatron.training import get_args
+from megatron.core.models.multimodal import context_parallel
+
+
+@dataclass
+class ConversationTemplateConfig:
+    system: str = None
+    chat_template: str = None
+
+
+
+@dataclass
+class LlavaConversationTemplateConfig(ConversationTemplateConfig):
+    """Default system prompt and chat template for Llava training."""
+
+    system: str = None
+    chat_template: str = None
+
+class ModelType(Enum):
+    LLAVA_VLM = "llava_vlm"
+    VIDEO_LLAVA_VLM = "video_llava_vlm"
+
+def predict_seq_len_with_padding(instance_tokens: torch.Tensor, pad_to_multiple_of: int = 64) -> int:
+    """Get seqlen with padding.
+    Args:
+        instance_tokens (torch.Tensor): Tensor of instance tokens.
+        pad_to_multiple_of (int): Pad to multiple of this value.
+    Returns:
+        int: Padded sequence length.
+    """
+    seqlen = len(instance_tokens)
+    seqlen_padded = (seqlen + pad_to_multiple_of - 1) // pad_to_multiple_of * pad_to_multiple_of
+    return seqlen_padded
+
+def group_samples(samples: List[Dict[str, torch.Tensor]], 
+                  group_size: int, 
+                  lengths: List[int],
+                  ) -> List[List[Dict[str, torch.Tensor]]]:
+    """Group samples into groups of size group_size.
+
+    Args:
+        samples (List[Dict[str, torch.Tensor]]): List of samples to group.
+        group_size (int): Maximum size of each group.
+        lengths (List[int]): List of lengths of each sample.
+
+    Returns:
+        List[List[Dict[str, torch.Tensor]]]: List of groups, where each group is a list of samples
+                that should be packed together. Each group's total length will not exceed group_size.
+    """
+    # create a max heap of the lengths
+    max_heap: List[Tuple[int, int]] = [(-length, i) for i, length in enumerate(lengths)]
+    heapq.heapify(max_heap)
+
+    groups: List[List[Dict[str, torch.Tensor]]] = []
+    current_group: List[Dict[str, torch.Tensor]] = []
+    current_length: int = 0
+    while max_heap:
+        neg_length, i = heapq.heappop(max_heap)
+        length = -neg_length
+        if current_length + length <= group_size:
+            current_group.append(samples[i])
+            current_length += length
+        else:
+            groups.append(current_group)
+            current_group = [samples[i]]
+            current_length = length
+    # If we're at the end of the samples, add the last group
+    if current_group:
+        groups.append(current_group)
+    return groups
+
+class VLMTaskEncoder(
+    DefaultTaskEncoder[
+        Union[VQASample],
+        dict,
+        dict,
+        dict,
+    ]
+):
+    def __init__(
+        self,
+        model_type: ModelType,
+        processor,
+        conversation_template_config: Optional[ConversationTemplateConfig] = None,
+        max_seq_length: Optional[int] = None,
+    ):
+        """Initialize VLMTaskEncoder.
+
+        Args:
+            model_name (str): Model name, currently only "llava_vlm" is supported.
+            processor: HuggingFace processor for the model.
+            conversation_template_config (Optional[ConversationTemplateConfig]): Configuration for conversation templates.
+            max_seq_length (Optional[int]): Maximum sequence length for packing. Should be sum of max_text_length
+                and image_seq_length. If None, defaults to 4096. This value is used as group_size for sequence packing.
+        """
+        self.model_type = model_type
+        # Use max_seq_length if provided, otherwise default to 4096
+        self.group_size = max_seq_length if max_seq_length is not None else 4096
+        self.processor = processor
+        self.conversation_template_config = conversation_template_config
+        # Read parallelism settings directly from training args (these live in TransformerConfig).
+        _args = get_args()
+        self._cp_size = getattr(_args, 'context_parallel_size', 1)
+        self._tp_size = getattr(_args, 'tensor_model_parallel_size', 1)
+        self._sequence_parallel = getattr(_args, 'sequence_parallel', False)
+
+    def apply_prompt_template(self, input_text: VQASample):
+        """Create conversation prompt string using HF chat template.
+
+        The first user turn always contains an image placeholder, later turns are text-only.
+        Returns a *prompt string* that can be fed into the processor together with an image.
+        """
+
+        user_msgs = input_text.context
+        bot_msgs = input_text.answers
+
+        def _ensure_list_type(value):
+            if isinstance(value, list):
+                return value
+            return [value]
+        user_msgs = _ensure_list_type(user_msgs)
+        bot_msgs = _ensure_list_type(bot_msgs)
+
+        conversation = []
+        for _, (u_txt, b_txt) in enumerate(zip(user_msgs, bot_msgs)):
+            conversation.append(
+                {
+                    "role": "user",
+                    "content": [{"type": "text", "text": u_txt}],
+                }
+            )
+            conversation.append(
+                {
+                    "role": "assistant",
+                    "content": [{"type": "text", "text": b_txt}],
+                }
+            )
+
+        # Inject optional system message
+        if (
+            self.conversation_template_config
+            and self.conversation_template_config.system
+        ):
+            conversation.insert(
+                0,
+                {"role": "system", "content": self.conversation_template_config.system},
+            )
+
+        # Select chat template
+        if (
+            self.conversation_template_config
+            and self.conversation_template_config.chat_template
+        ):
+            self.processor.chat_template = (
+                self.conversation_template_config.chat_template
+            )
+        return self.processor.apply_chat_template(
+            conversation,
+            tokenize=False,
+            add_generation_prompt=False,
+        )
+    
+
+    def _find_pattern_indices(
+        self, template, pattern, start_idx=0, allow_first_mismatch=False
+    ):
+        template_len = len(template)
+        pat_len = len(pattern)
+        for i in range(start_idx, template_len - pat_len + 1):
+            match = template[i : i + pat_len] == pattern
+            if torch.all(match) or (allow_first_mismatch and torch.all(match[1:])):
+                return i, i + pat_len
+        return -1, -1
+
+    def select_samples_to_pack(self, samples: List[Dict[str, torch.Tensor]]) -> List[List[Dict[str, torch.Tensor]]]:
+        """Selects which samples will be packed together.
+        
+        This function receives a list of samples (size according to the selected packing_buffer_size), 
+        and partitions those samples into groups that shall be packed together.
+
+        Args:
+            samples (List[Dict[str, torch.Tensor]]): List of samples from the buffer, each containing
+                tokenized data with keys like 'input_ids', 'labels', 'loss_mask', etc.
+
+        Returns:
+            List[List[Dict[str, torch.Tensor]]]: List of groups, where each group is a list of samples
+                that should be packed together. Each group's total length will not exceed group_size.
+
+        NOTE: Energon dataloader calls this method internally if packing is used.
+        Please see https://nvidia.github.io/Megatron-Energon/advanced/packing.html
+        """
+        # Group samples into groups of size group_size
+        lengths = [predict_seq_len_with_padding(sample["input_ids"]) for sample in samples]
+        # lengths = [sample["input_ids"].size(0) for sample in samples]
+        packed_samples = group_samples(samples, group_size=self.group_size, lengths=lengths)
+        return packed_samples
+    
+    @stateless
+    def pack_selected_samples(self, samples: List[Dict[str, torch.Tensor]]) -> Dict[str, torch.Tensor]:
+        """Implements how a group of samples will be mapped to a single sample.
+        
+        Args:
+            samples (List[Dict[str, torch.Tensor]]): List of samples to pack together.
+
+        Returns:
+            Dict[str, torch.Tensor]: Packed sample with keys like 'input_ids', 'labels', 'loss_mask', etc.
+        """
+        # Pad each sample to a multiple of 64, then concatenate
+        padded_input_ids = []
+        padded_labels = []
+        padded_loss_masks = []
+        padded_lens = []
+
+        has_labels = "labels" in samples[0] and samples[0]["labels"] is not None
+        has_loss_mask = "loss_mask" in samples[0] and samples[0]["loss_mask"] is not None
+
+        for sample in samples:
+            original_len = sample["input_ids"].size(0)
+            padded_len = predict_seq_len_with_padding(sample["input_ids"])
+            padded_lens.append(padded_len)
+            pad_amount = padded_len - original_len
+
+            padded_input_ids.append(torch.cat([
+                sample["input_ids"],
+                torch.zeros(pad_amount, dtype=sample["input_ids"].dtype)
+            ]))
+            
+            if has_labels:
+                padded_labels.append(torch.cat([
+                    sample["labels"],
+                    torch.full((pad_amount,), -100, dtype=sample["labels"].dtype)
+                ]))
+
+            if has_loss_mask:
+                padded_loss_masks.append(torch.cat([
+                    sample["loss_mask"],
+                    torch.zeros(pad_amount, dtype=sample["loss_mask"].dtype)
+                ]))
+
+        # Concatenate sequences
+        input_ids = torch.cat(padded_input_ids)
+        labels = torch.cat(padded_labels) if has_labels else None
+        loss_mask = torch.cat(padded_loss_masks) if has_loss_mask else None
+        
+        batched_images = torch.stack([s["pixel_values"] for s in samples], dim=0)   # (B , C , H , W)
+        
+        # Calculate padding if context parallel or sequence parallel is enabled
+        pad_len = 0
+        if self._cp_size > 1 or self._sequence_parallel:
+            pad_len = context_parallel.get_padding(
+                len(input_ids),
+                self._cp_size,
+                self._tp_size,
+                self._sequence_parallel,
+            )
+        
+        # Pad sequences
+        if pad_len > 0:
+            input_ids = torch.cat([input_ids, torch.zeros(pad_len, dtype=input_ids.dtype)])
+            if labels is not None:
+                labels = torch.cat([labels, torch.full((pad_len,), -100, dtype=labels.dtype)])
+            if loss_mask is not None:
+                loss_mask = torch.cat([loss_mask, torch.zeros(pad_len, dtype=loss_mask.dtype)])
+        
+        # Generate position_ids after padding
+        position_ids = torch.arange(len(input_ids))
+        
+        # Calculate cu_seqlens using padded lengths
+        lens = torch.tensor(padded_lens, dtype=torch.int32)
+        cu_seqlens = torch.cat([torch.tensor([0], dtype=torch.int32), torch.cumsum(lens, dim=0)])
+        
+        # Calculate padded sequence lengths and cu_seqlens
+        seqlens_padded = [l.item() + pad_len for l in lens]
+        cu_seqlens_padded = torch.cat([torch.tensor([0], dtype=torch.int32), torch.cumsum(torch.tensor(seqlens_padded, dtype=torch.int32), dim=0)])
+        
+        packing_kwargs = {
+            "cu_seqlens_q": cu_seqlens,
+            "cu_seqlens_kv": cu_seqlens,
+            "cu_seqlens_q_padded": cu_seqlens_padded,
+            "cu_seqlens_kv_padded": cu_seqlens_padded,
+            "max_seqlen_q": torch.tensor(max(seqlens_padded), dtype=torch.int32),
+            "max_seqlen_kv": torch.tensor(max(seqlens_padded), dtype=torch.int32),
+        }
+        
+        packed_result = {
+            "input_ids": input_ids,
+            "labels": labels,
+            "loss_mask": loss_mask,
+            "pixel_values": batched_images,
+            "position_ids": position_ids,
+            "packing_kwargs": packing_kwargs,
+        }
+            
+        return packed_result
+
+    @stateless
+    def encode_sample(self, sample: VQASample):
+        """Return tokenised multimodal sample."""
+        # Build prompt
+        prompt = self.apply_prompt_template(sample)
+        logging.debug(f"prompt: {prompt}")
+
+        # Process image + prompt
+        inputs = self.processor(
+            images=getattr(sample, "image", None),
+            text=prompt,
+            add_special_tokens=False,
+            return_tensors="pt",
+            do_rescale=False,
+        )
+
+        # Remove batch dim
+        for k, v in inputs.items():
+            inputs[k] = v.squeeze(0)
+
+
+        answers = sample.answers
+        if answers:
+            if not isinstance(answers, list):
+                answers = [answers]
+            tokenizer = self.processor.tokenizer
+            inputs["labels"] = torch.full_like(inputs["input_ids"], fill_value=-100)
+            search_idx = 0
+            for ans in answers:
+                answer_tokens = tokenizer.encode(
+                    ans, add_special_tokens=False, return_tensors="pt"
+                )[0]
+                s_idx, e_idx = self._find_pattern_indices(
+                    inputs["input_ids"], answer_tokens, search_idx
+                )
+                if s_idx == -1:
+                    raise ValueError(f"Answer not found in input_ids: {ans}")
+                inputs["labels"][s_idx:e_idx] = inputs["input_ids"][s_idx:e_idx]
+                search_idx = e_idx
+
+            # shift inputs and labels by 1
+            inputs["input_ids"] = inputs["input_ids"][:-1]
+            inputs["labels"] = inputs["labels"][1:]
+            inputs["loss_mask"] = (inputs["labels"] != -100).long()
+
+        else:
+            inputs["labels"] = None
+            inputs["loss_mask"] = None
+        
+        return inputs
+
+    def batch(self, samples: List[Dict]) -> Dict:
+        """Pad/stack individual samples into a single batch dict."""
+        if not samples:
+            return {}
+
+        batched: Dict[str, torch.Tensor] = {}
+        keys = samples[0].keys()
+        is_packed_sample = "packing_kwargs" in samples[0]
+        for key in keys:
+            values = [s[key] for s in samples if key in s and s[key] is not None]
+
+            processor = KEY_PROCESSORS.get(key)
+            if processor is not None:
+               batched[key] = processor(values, max_len=self.group_size, is_packed_sample=is_packed_sample) 
+               continue
+            
+            # Fallback behaviours if no specific processor is registered.
+            if isinstance(values[0], torch.Tensor):
+               batched[key] = torch.stack(values, dim=0)
+            else:
+               batched[key] = values
+        
+        # Add context parallel padding if enabled
+        if self._cp_size > 1:
+            seq_len = batched["input_ids"].size(1)
+            pad_len = context_parallel.get_padding(
+                seq_len,
+                self._cp_size,
+                self._tp_size,
+                self._sequence_parallel,
+            )
+            if pad_len > 0:
+                # Pad input_ids
+                batched["input_ids"] = torch.cat([
+                    batched["input_ids"],
+                    torch.zeros(batched["input_ids"].size(0), pad_len, dtype=batched["input_ids"].dtype)
+                ], dim=1)
+                # Pad labels
+                if "labels" in batched:
+                    batched["labels"] = torch.cat([
+                        batched["labels"],
+                        torch.full((batched["labels"].size(0), pad_len), -100, dtype=batched["labels"].dtype)
+                    ], dim=1)
+                # Pad loss_mask
+                if "loss_mask" in batched:
+                    batched["loss_mask"] = torch.cat([
+                        batched["loss_mask"],
+                        torch.zeros(batched["loss_mask"].size(0), pad_len, dtype=batched["loss_mask"].dtype)
+                    ], dim=1)
+        
+        return batched
+
+    def encode_batch_vlm_clip_llava(self, batch_data: Dict) -> Dict:
+        input_ids = batch_data["input_ids"]
+        labels = batch_data.get("labels")
+        loss_mask = batch_data.get("loss_mask")
+
+        # Handle packed-sample case where input_ids is 1-D
+        if input_ids.dim() == 1:
+            input_ids = input_ids.unsqueeze(0)  # add batch dimension
+            if labels is not None and labels.dim() == 1:
+                labels = labels.unsqueeze(0)
+            if loss_mask is not None and loss_mask.dim() == 1:
+                loss_mask = loss_mask.unsqueeze(0)
+
+        seq_len = input_ids.size(1)
+        position_ids = torch.arange(seq_len, dtype=torch.long, device=input_ids.device)
+        position_ids = position_ids.unsqueeze(0).repeat(input_ids.size(0), 1)
+        pixel_values = batch_data.get("pixel_values")
+
+        output = {
+            "input_ids": input_ids,
+            "labels": labels,
+            "loss_mask": loss_mask,
+            "position_ids": position_ids,
+        }
+
+        if pixel_values is not None:
+            output["modality_inputs"] = {
+                "images": {"clip_encoder": {"pixel_values": pixel_values}}
+            }
+        
+        return output
+
+    def encode_batch_vlm_clip_llava_video(self, batch_data: Dict) -> Dict:
+        input_ids = batch_data["input_ids"]
+        labels = batch_data.get("labels")
+        loss_mask = batch_data.get("loss_mask")
+
+        seq_len = input_ids.size(1)
+        position_ids = torch.arange(seq_len, dtype=torch.long, device=input_ids.device)
+        position_ids = position_ids.unsqueeze(0).repeat(input_ids.size(0), 1)
+
+        pixel_values_videos = batch_data.get("pixel_values_videos")
+
+        output = {
+            "input_ids": input_ids,
+            "labels": labels,
+            "loss_mask": loss_mask,
+            "position_ids": position_ids,
+        }
+
+        if pixel_values_videos is not None:
+            output["modality_inputs"] = {
+                "images": {"clip_encoder": {"pixel_values": pixel_values_videos}}
+            }
+
+        return output
+
+    def encode_batch(self, batch_data: Dict) -> dict:
+        if self.model_type is ModelType.LLAVA_VLM:
+            return self.encode_batch_vlm_clip_llava(batch_data)
+        elif self.model_type is ModelType.VIDEO_LLAVA_VLM:
+            return self.encode_batch_vlm_clip_llava_video(batch_data)
+        else:
+            raise ValueError(f"Model type {self.model_type} not supported")
+
+def llava_vlm_dataloader_provider(train_val_test_num_samples, max_seq_length: Optional[int] = None, is_video_input: bool = False):
+    args = get_args()
+    tokenizer_model_id = args.tokenizer_model
+    processor = AutoProcessor.from_pretrained(tokenizer_model_id)
+    if is_video_input:
+        model_type = ModelType.VIDEO_LLAVA_VLM
+    else:
+        model_type = ModelType.LLAVA_VLM
+    return train_valid_test_dataloaders_provider(
+        train_val_test_num_samples,
+        task_encoder=VLMTaskEncoder(
+            model_type=model_type,
+            processor=processor,
+            conversation_template_config=LlavaConversationTemplateConfig(),
+            max_seq_length=max_seq_length,
+        )
+    )
+
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--data_path",
+        type=str,
+        required=True,
+        help="path to the dataset directory in energon format",
+    )
+    parser.add_argument('--total-seq-length', type=int, default=512, help='Maximum text length')
+    parser.add_argument('--image-seq-length', type=int, default=197, help='Number of image tokens')
+    parser.add_argument('--packing-buffer-size', type=int, default=None, help='Packing buffer size when using sequence packing')
+    args = parser.parse_args()
+    
+    # Calculate max_seq_length as sum of text and image sequence lengths
+    max_seq_length = args.max_text_length + args.image_seq_length
+    
+    model_name = "llava-hf/llava-1.5-7b-hf"
+
+    processor = AutoProcessor.from_pretrained(model_name)
+    worker_config = WorkerConfig.default_worker_config(0)
+    train_loader = get_loader(
+        get_train_dataset(
+            args.data_path,
+            batch_size=8,
+            shuffle_buffer_size=None,
+            max_samples_per_sequence=None,
+            task_encoder=VLMTaskEncoder(
+                model_type=ModelType.LLAVA_VLM,
+                processor=processor,
+                conversation_template_config=LlavaConversationTemplateConfig(),
+                max_seq_length=max_seq_length,  # Use calculated max_seq_length
+            ),
+            worker_config=worker_config,
+        ),
+        worker_config=worker_config,
+    )
+
+    print(f"data loader length {len(train_loader)}")
+    for index, each_batch in enumerate(train_loader):
+        print(
+            f"batch index {index} tokens {each_batch['input_ids']} images shape \
+               {each_batch['modality_inputs']['images']['clip_encoder']['pixel_values'].shape}"
+        )
+        break
+
+
+# -----------------------------------------------------------------------------
+# Key processing utilities for batching
+# -----------------------------------------------------------------------------
+
+
+class KeyProcessor(Protocol):
+    """Callable that aggregates a list of tensors into a single batched tensor."""
+
+    def __call__(self, values: List[torch.Tensor], max_len: Optional[int] = None, is_packed_sample: bool = False) -> torch.Tensor:  # pragma: no cover
+        ...
+
+
+class StackProcessor:
+    """Simply stack tensors along a given dimension."""
+
+    def __init__(self, dim: int = 0):
+        self.dim = dim
+
+    def __call__(self, values: List[torch.Tensor], max_len: Optional[int] = None, is_packed_sample: bool = False) -> torch.Tensor:
+        if values[0].dim() == 3:
+            return torch.stack(values, dim=self.dim) # (B , C , H , W)
+        else:
+            # Concatenate already-batched image tensors along the batch dimension.
+            return torch.cat(values, dim=self.dim)  # (B , C , H , W)
+
+
+class PaddingProcessor:
+    """Pad variable-length sequences to the same length."""
+
+    def __init__(self, pad_value: int, batch_first: bool = True):
+        self.pad_value = pad_value
+        self.batch_first = batch_first
+    
+    def _pad_and_stack(self, tensors: List[torch.Tensor], max_len: int, pad_val: int) -> torch.Tensor:
+        """Pad or truncate a list of 1D tensors to a fixed length and stack them."""
+        padded_tensors = []
+        for t in tensors:
+            current_len = t.size(0)
+            if current_len > max_len:
+                # Truncate
+                padded_tensors.append(t[:max_len])
+            else:
+                # Pad
+                pad_amount = max_len - current_len
+                padding = torch.full((pad_amount,), pad_val, dtype=t.dtype, device=t.device)
+                padded_tensors.append(torch.cat([t, padding]))
+        return torch.stack(padded_tensors, dim=0)
+
+    def __call__(self, values: List[torch.Tensor], max_len: Optional[int] = None, is_packed_sample: bool = False) -> torch.Tensor:
+        if is_packed_sample:
+            return rnn_utils.pad_sequence(
+                    values, batch_first=self.batch_first, padding_value=self.pad_value
+                    )
+        else:
+            return self._pad_and_stack(values, max_len, self.pad_value)
+
+class PackingKwargsProcessor:
+    """Extract the value at first index for packing_kwargs"""
+
+    def __call__(self, values: List[torch.Tensor], max_len: Optional[int] = None, is_packed_sample: bool = False) -> torch.Tensor:
+        if len(values) == 1:
+            return values[0]
+        else:
+            raise ValueError("Multiple packing_kwargs found in batch; expected only one per batch.")
+
+class GenericStackProcessor:
+
+    def __init__(self, dim: int = 0):
+        self.dim = dim
+
+    def __call__(self, values: List[torch.Tensor], max_len: Optional[int] = None, is_packed_sample: bool = False) -> torch.Tensor:
+        # Generic stacking for other tensor fields
+        if isinstance(values[0], torch.Tensor):
+            return torch.stack(values, dim=self.dim)
+        else:
+            return values
+
+# Registry mapping sample keys to their corresponding processor.
+KEY_PROCESSORS: Dict[str, KeyProcessor] = {
+    "pixel_values": StackProcessor(),
+    "pixel_values_videos": StackProcessor(),
+    "input_ids": PaddingProcessor(pad_value=0),
+    "attention_mask": PaddingProcessor(pad_value=0),
+    "loss_mask": PaddingProcessor(pad_value=0),
+    "labels": PaddingProcessor(pad_value=-100),
+    "packing_kwargs": PackingKwargsProcessor(),
+}

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/data/mock.py

@@ -0,0 +1,296 @@
+# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+"""
+Simple mock data module for testing MIMO with image-text (VLM) models.
+
+This module provides basic synthetic data generation for testing Vision Language Models
+within the MIMO framework.
+"""
+
+from typing import Callable, Dict, List, Optional
+
+import torch
+from torch.utils.data import DataLoader, Dataset
+
+
+def create_mock_image(image_size: int = 336) -> torch.Tensor:
+    """
+    Create a simple mock image (all zeros).
+
+    Args:
+        image_size: Size of the square image
+
+    Returns:
+        Tensor of shape [3, H, W] with all zeros
+    """
+    return torch.zeros(3, image_size, image_size)
+
+
+def create_mock_caption() -> str:
+    """
+    Create a simple mock caption.
+
+    Returns:
+        A simple caption string
+    """
+    return "This is an image."
+
+
+class MockVLMDataset(Dataset):
+    """Simple dataset of mock image-text pairs for VLM testing."""
+
+    def __init__(
+        self,
+        size: int = 10000,
+        image_size: int = 336,
+        seq_len: int = 512,
+        image_seq_length: int = 32,
+        vocab_size: int = 256,
+        tokenizer: Optional[Callable] = None,
+        pad_token_id: int = 0,
+        image_token_id: int = 32000,
+    ):
+        """
+        Initialize the mock VLM dataset.
+
+        Args:
+            size: Number of examples in the dataset
+            image_size: Size of the square images
+            seq_len: Total length of the token sequence (image + text)
+            image_seq_length: Number of image tokens to pad
+            vocab_size: Size of the vocabulary for tokenization
+            tokenizer: Optional tokenizer function
+            pad_token_id: ID for padding token
+            image_token_id: ID for image placeholder token
+        """
+        self.size = size
+        self.image_size = image_size
+        self.seq_len = seq_len
+        self.image_seq_length = image_seq_length
+        self.vocab_size = vocab_size
+        self.tokenizer = tokenizer
+
+        # Special token IDs
+        self.pad_token_id = pad_token_id
+        self.image_token_id = image_token_id
+
+        if self.seq_len < self.image_seq_length:
+            raise ValueError(
+                f"seq_len ({self.seq_len}) must be >= image_seq_length ({self.image_seq_length})."
+            )
+
+    def __len__(self) -> int:
+        """Return the size of the dataset."""
+        return self.size
+
+    def __getitem__(self, idx: int) -> Dict:
+        """
+        Get an item from the dataset.
+
+        Args:
+            idx: Index of the item (ignored, all items are identical)
+
+        Returns:
+            Dictionary containing:
+            - images: Tensor of shape [C, H, W]
+            - input_ids: Tokenized caption with image token
+            - labels: Shifted input_ids for language modeling
+            - loss_mask: Mask for loss calculation
+            - position_ids: Position IDs for the tokens
+        """
+        # Create a zero image
+        image = create_mock_image(self.image_size)
+
+        # Generate random token sequence for this sample.
+        input_ids = self._mock_tokenize()
+
+        # Create labels (shifted input_ids)
+        labels = input_ids.clone()
+        labels[:-1] = input_ids[1:]
+        labels[-1] = self.pad_token_id  # Padding for the last position
+
+        # Set labels for image tokens to -100 (ignored in loss calculation)
+        labels[input_ids == self.image_token_id] = -100
+
+        # Create loss mask (1 for tokens to calculate loss on, 0 for others)
+        loss_mask = torch.ones_like(input_ids).float()
+        loss_mask[input_ids == self.pad_token_id] = 0.0  # Don't calculate loss on padding
+        loss_mask[input_ids == self.image_token_id] = 0.0  # Don't calculate loss on image tokens
+
+        # Create position IDs (just sequential integers)
+        position_ids = torch.arange(len(input_ids), dtype=torch.long)
+
+        return {
+            "input_ids": input_ids,
+            "labels": labels,
+            "loss_mask": loss_mask,
+            "position_ids": position_ids,
+            "modality_inputs": {
+                "clip_encoder": {
+                    "images": image,
+                }
+            },
+        }
+
+    def _mock_tokenize(self) -> torch.Tensor:
+        """
+        Generate a mock token sequence consisting of ``image_seq_length`` image tokens followed by
+        randomly generated text tokens such that the total sequence length equals
+        ``self.seq_len``.
+
+        Returns:
+            torch.Tensor: Tensor of token IDs of shape ``[seq_len]``.
+        """
+
+        # Image placeholder tokens ─ placed at the beginning of the sequence to mimic
+        # the layout produced by many VLM tokenizers.
+        image_tokens = torch.full(
+            (self.image_seq_length,), self.image_token_id, dtype=torch.long
+        )
+
+        # Random text tokens drawn uniformly in ``[1, vocab_size)`` (we reserve ``0`` for pad).
+        num_text_tokens = self.seq_len - self.image_seq_length
+        text_tokens = torch.randint(
+            low=1,
+            high=self.vocab_size,
+            size=(num_text_tokens,),
+            dtype=torch.long,
+        )
+
+        # Concatenate to form the full sequence.
+        token_ids = torch.cat((image_tokens, text_tokens), dim=0)
+
+        return token_ids
+
+
+def get_mock_vlm_dataloader(
+    batch_size: int = 8,
+    dataset_size: int = 100,
+    image_size: int = 224,
+    seq_len: int = 77,
+    image_seq_length: int = 32,
+    num_workers: int = 0,
+    pad_token_id: int = 0,
+    image_token_id: int = 50000,
+) -> DataLoader:
+    """
+    Create a DataLoader for mock VLM data.
+
+    Args:
+        batch_size: Batch size
+        dataset_size: Size of the dataset
+        image_size: Size of the square images
+        seq_len: Total length of the token sequence (image + text)
+        image_seq_length: Number of image tokens to pad
+        num_workers: Number of worker processes for data loading
+        pad_token_id: ID for padding token
+        image_token_id: ID for image placeholder token
+
+    Returns:
+        DataLoader for the mock VLM dataset
+    """
+    dataset = MockVLMDataset(
+        size=dataset_size,
+        image_size=image_size,
+        seq_len=seq_len,
+        image_seq_length=image_seq_length,
+        pad_token_id=pad_token_id,
+        image_token_id=image_token_id,
+    )
+
+    dataloader = DataLoader(
+        dataset,
+        batch_size=batch_size,
+        shuffle=True,
+        num_workers=num_workers,
+        collate_fn=lambda batch: _collate_fn(batch),
+    )
+
+    return dataloader
+
+
+def _collate_fn(batch: List[Dict]) -> Dict[str, torch.Tensor]:
+    """
+    Collate function for the DataLoader.
+
+    Args:
+        batch: List of dictionaries from the dataset
+
+    Returns:
+        Dictionary of batched tensors
+    """
+    images = torch.stack([item["images"] for item in batch])
+    input_ids = torch.stack([item["input_ids"] for item in batch])
+    labels = torch.stack([item["labels"] for item in batch])
+    loss_mask = torch.stack([item["loss_mask"] for item in batch])
+    position_ids = torch.stack([item["position_ids"] for item in batch])
+
+    return {
+        "input_ids": input_ids,
+        "labels": labels,
+        "loss_mask": loss_mask,
+        "position_ids": position_ids,
+        "modality_inputs": {
+            "clip_encoder": {
+                "images": images,
+            }
+        },
+    }
+
+
+def train_valid_test_datasets_provider(train_val_test_num_samples):
+    """Provide datasets for training, validation, and testing."""
+    from megatron.core import mpu
+    from megatron.training import get_args
+
+    args = get_args()
+
+    # Print some info to confirm args are available
+    print(f"Creating datasets with batch size: {args.micro_batch_size}")
+    print(f"Image size: {args.image_size}")
+    print(f"Image sequence length: {args.image_seq_length}")
+    print(f"Total sequence length: {args.total_seq_length}")
+
+    # Only build dataset on tensor parallel rank 0
+    if mpu.get_tensor_model_parallel_rank() == 0:
+
+        from examples.mimo.data.mock import MockVLMDataset
+
+        train_dataset = MockVLMDataset(
+            size=train_val_test_num_samples[0],
+            image_size=args.image_size,
+            seq_len=args.total_seq_length,
+            image_seq_length=args.image_seq_length,
+            pad_token_id=args.pad_token_id,
+            image_token_id=args.image_token_id,
+        )
+
+        # Use the same dataset type for validation
+        valid_dataset = MockVLMDataset(
+            size=train_val_test_num_samples[1] if train_val_test_num_samples[1] > 0 else 100,
+            image_size=args.image_size,
+            seq_len=args.total_seq_length,
+            image_seq_length=args.image_seq_length,
+            pad_token_id=args.pad_token_id,
+            image_token_id=args.image_token_id,
+        )
+
+        # No test dataset for now
+        test_dataset = None
+    else:
+        train_dataset = None
+        valid_dataset = None
+        test_dataset = None
+
+    return train_dataset, valid_dataset, test_dataset
+
+if __name__ == "__main__":
+    print("\nCreating mock VLM dataloader...")
+    dataloader = get_mock_vlm_dataloader(batch_size=4, dataset_size=10)
+
+    print(f"DataLoader has {len(dataloader)} batches")
+
+    for batch in dataloader:
+        print("\nBatch from dataloader:")
+        for key, tensor in batch.items():
+            print(f"  {key}: {tensor.shape}")
+        break

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/data/prepare_video_llava_data.py

@@ -0,0 +1,106 @@
+import glob
+import json
+import os
+import tarfile
+
+import webdataset as wds
+from huggingface_hub import snapshot_download
+from tqdm import tqdm
+
+
+def _extract_archives(root: str):
+    """Extract every .tar / .tar.gz archive found under *root* into its directory."""
+    archives = glob.glob(os.path.join(root, "**", "*.tar*"), recursive=True)
+    for arch in archives:
+        try:
+            print(f"Extracting {arch} …")
+            with tarfile.open(arch, "r:*") as tf:
+                tf.extractall(path=os.path.dirname(arch))
+        except Exception as e:
+            print(f"[WARN] Failed to extract {arch}: {e}")
+
+
+def convert_llava_video_to_wds(dataset_root: str, shard_size: int = 8000):
+    """Convert a LLaVA-Video dataset (keys: video, conversations, data_source) to WebDataset format.
+
+    The function walks through every *.json / *.jsonl annotation file located under *dataset_root*,
+    finds the referenced video files, and writes shards (<dataset_root>/wds/video-000000.tar …).
+    """
+    # ensure archives extracted so that video files are accessible
+    _extract_archives(dataset_root)
+
+    output_dir = os.path.join(dataset_root, "wds")
+    os.makedirs(output_dir, exist_ok=True)
+
+    # gather annotation files (skip the output directory itself)
+    annotation_files = [
+        p
+        for p in glob.glob(os.path.join(dataset_root, "**", "*.json*"), recursive=True)
+        if not os.path.commonpath([p, output_dir]) == output_dir
+    ]
+    if not annotation_files:
+        raise FileNotFoundError(f"No annotation JSON files found in {dataset_root}")
+    
+    print(f"Found annotation files -  {annotation_files}")
+
+    shard_pattern = os.path.join(output_dir, "video-%06d.tar")
+    sample_idx = 0
+    with wds.ShardWriter(shard_pattern, maxcount=shard_size) as sink:
+        for ann_path in annotation_files:
+            print(f"Processing {ann_path} …")
+            with open(ann_path, "r") as f:
+                first = f.read(1)
+                f.seek(0)
+                entries = json.load(f) if first == "[" else [json.loads(line) for line in f if line.strip()]
+            for entry in tqdm(entries):
+                video_rel = entry.get("video")
+                conversations = entry.get("conversations")
+                if video_rel is None or conversations is None:
+                    continue
+
+                video_path = video_rel if os.path.isabs(video_rel) else os.path.join(dataset_root, video_rel)
+
+                if not os.path.exists(video_path):
+                    print(f"Video file not found: {video_path}")
+                    # or raise an error
+                    continue
+
+                try:
+                    with open(video_path, "rb") as vf:
+                        video_bytes = vf.read()
+                except Exception:
+                    continue
+
+                key = f"{sample_idx:09d}"
+                ext = os.path.splitext(video_path)[1].lstrip(".").lower() or "mp4"
+                sample = {
+                    "__key__": key,
+                    ext: video_bytes,
+                    "json": json.dumps(conversations).encode(),
+                }
+                if entry.get("data_source"):
+                    sample["src.txt"] = str(entry["data_source"]).encode()
+
+                sink.write(sample)
+                sample_idx += 1
+
+    print(f"Finished writing {sample_idx} samples → {output_dir}")
+
+
+if __name__ == "__main__":
+    # download dataset
+    dataset_name = "lmms-lab/LLaVA-Video-178K"
+
+    # specific subset to download
+    subset = "0_30_s_academic_v0_1"
+
+    dataset_root = snapshot_download(
+        repo_id=dataset_name,
+        repo_type="dataset",
+        local_dir_use_symlinks=False,
+        resume_download=True,
+        allow_patterns=[f"{subset}/*", f"{subset}.*"],
+    )
+    print(f"dataset downloaded to: {dataset_root}")
+    # convert to webdataset
+    convert_llava_video_to_wds(f"{dataset_root}/{subset}")

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/data/utils/calculate_audio_tokens.py

@@ -0,0 +1,65 @@
+import math
+import torch
+from types import SimpleNamespace
+
+# Model-specific audio processing parameters
+AUDIO_MODEL_PARAMS = {
+    "openai/whisper-base": {
+        "model_type": "whisper",
+        "sample_rate": 16000,  # 16kHz
+        "window_stride": 0.01,  # 10ms
+        "encoder_down_sampling": 2,
+        "d_model": 512,
+        "max_length_seconds": 30.0,
+    },
+}
+
+
+def calculate_num_mel_frames(audio_length, sample_rate, window_stride, window_length=None):
+    """
+    Calculate the number of mel frames from an audio signal.
+
+    Parameters:
+    - audio_length (int): Total number of audio samples.
+    - sample_rate (int or float): Sampling rate of the audio (samples per second).
+    - window_stride (float): The time (in seconds) between successive frames.
+    - window_length (float, optional): Window length in seconds. If provided, this function
+      uses the standard formula: floor((N - window_length_in_samples) / hop_length) + 1.
+      Otherwise, it uses the simplified calculation based on the window stride only.
+
+    Returns:
+    - int: The number of mel frames.
+    """
+    hop_length_samples = int(window_stride * sample_rate)
+
+    if window_length is None:
+        num_frames = math.ceil((audio_length + 1) / hop_length_samples)
+    else:
+        window_length_samples = int(window_length * sample_rate)
+        num_frames = math.floor((audio_length - window_length_samples) / hop_length_samples) + 1
+
+    return num_frames
+
+
+def calculate_num_audio_tokens(audio_tensor, model_name):
+
+    # Get audio length in samples
+    audio_length = audio_tensor.shape[1]
+
+    # Get model parameters
+    if model_name in AUDIO_MODEL_PARAMS:
+        model_params = SimpleNamespace(**AUDIO_MODEL_PARAMS[model_name])
+        model_type = model_params.model_type
+    else:
+        raise ValueError(f"Unsupported model name: {model_name}")
+
+
+    if model_type == "whisper":
+        num_mel_frames = calculate_num_mel_frames(
+            audio_length, model_params.sample_rate, model_params.window_stride
+        )
+        encoder_seq_length = math.ceil(num_mel_frames / model_params.encoder_down_sampling)
+    else:
+        raise ValueError(f"Unsupported model type: {model_type}")
+
+    return max(1, int(encoder_seq_length))

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/model_providers/__init__.py

@@ -0,0 +1 @@
+ 

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/model_providers/hf_clip_encoder.py

@@ -0,0 +1,48 @@
+# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+
+import torch
+from transformers import CLIPVisionModel, LlavaNextVideoConfig
+from transformers.models.llava_next_video.modeling_llava_next_video import (
+    LlavaNextVideoPooler,
+)
+
+
+class HFCLIPEncoderWrapper(torch.nn.Module):
+    """CLIP encoder wrapper that extracts last_hidden_state."""
+
+    def __init__(self, feature_layer_index=-2, is_video_input: bool = False):
+        """Initialize the HFCLIPEncoderWrapper.
+
+        Args:
+            feature_layer_index (int): Index of the feature layer to extract from the encoder's hidden states.
+                                       Default is -2 (second to last layer).
+            is_video_input (bool): If True, expects video input and applies vision resampler.
+        """
+        super().__init__()
+        self.encoder = CLIPVisionModel.from_pretrained('openai/clip-vit-large-patch14-336')
+        self.encoder.eval()
+        self.feature_layer_index = feature_layer_index
+        self.is_video_input = is_video_input
+        if self.is_video_input:
+            config = LlavaNextVideoConfig()
+            self.vision_resampler = LlavaNextVideoPooler(config)
+
+    def forward(self, pixel_values: torch.Tensor):
+        """Input: (B, F, 3, 336, 336) if video, else (B, 3, 336, 336) or (num_frames, 3, 336, 336)."""
+        # Process through encoder and extract last_hidden_state
+        with torch.no_grad():
+            if self.is_video_input:
+                batch_size, frames, channels, height, width = pixel_values.shape
+                pixel_values = pixel_values.reshape(batch_size * frames, channels, height, width)
+            
+
+            last_hidden_state = self.encoder(pixel_values, output_hidden_states=True)
+            # -1 index is image features
+            image_features = last_hidden_state[-1]
+            # select last but second layer
+            image_features = image_features[self.feature_layer_index]
+            # drop cls token
+            image_features = image_features[:, 1:, :]
+            if self.is_video_input:
+                image_features = self.vision_resampler(image_features)
+            return image_features

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/model_providers/hf_whisper_encoder.py

@@ -0,0 +1,27 @@
+# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+
+import torch
+from transformers import WhisperConfig, WhisperModel
+
+class HFWhisperEncoderWrapper(torch.nn.Module):
+    """Whisper audio encoder wrapper that extracts last_hidden_state."""
+
+    def __init__(self, model_name: str):
+        super().__init__()
+        self.encoder = WhisperModel.from_pretrained(model_name).encoder
+
+    def forward(self, input_features, seq_lengths=None):
+        '''
+        input_features: torch.Tensor
+            input audio features
+        seq_lengths: torch.Tensor
+            the number of audio tokens corresponding to non-padded audio frames
+            we only get the embeddings for the non-padded audio frames
+        '''
+        with torch.no_grad():
+            hidden = self.encoder(input_features).last_hidden_state  # [b, s, h]
+            if seq_lengths is not None:
+                seq_len = hidden.shape[1]
+                mask = torch.arange(seq_len, device=hidden.device)[None, :] < seq_lengths[:, None]
+                hidden = hidden[mask]
+            return hidden

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/model_providers/llava_avlm.py

@@ -0,0 +1,187 @@
+# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+"""Model provider for a LLaVA-style Vision-Language Model.
+
+This provider assembles a MIMO model that consists of:
+• Vicuna-7B language model (Llama-based) built with Transformer-Engine GPT blocks.
+• CLIP ViT-L/14 visual encoder (336 px) that produces image patch embeddings.
+• A 2-layer MLP projector that maps vision embeddings into Vicuna hidden size.
+"""
+
+
+import torch
+from configs.llava_avlm import (
+    get_llava_projection_config,
+    get_llava_projection_layer_spec,
+    get_vicuna_language_layer_spec,
+    get_vicuna_language_model_config,
+)
+
+from examples.mimo.model_providers.hf_clip_encoder import HFCLIPEncoderWrapper
+from examples.mimo.model_providers.hf_whisper_encoder import HFWhisperEncoderWrapper
+from examples.mimo.utils.logging import print_mimo_structure
+from examples.mimo.utils.model_helpers import load_submodule_ckpt
+from megatron.core.models.gpt.gpt_model import GPTModel
+from megatron.core.models.mimo import MimoModel, MimoModelConfig
+from megatron.core.models.mimo.submodules.vision import VisionModalitySubmodules
+from megatron.core.models.mimo.submodules.audio import AudioModalitySubmodules
+from megatron.core.models.vision.multimodal_projector import MultimodalProjector
+from megatron.core.transformer.spec_utils import ModuleSpec
+
+
+def model_provider_llava_avlm(
+    pre_process: bool = True,
+    post_process: bool = True,
+    add_encoder=True,
+    add_decoder=True,
+    image_special_token_id: int = 32000,
+    audio_special_token_id: int = 32002,
+    pg_collection=None,
+):
+    """
+    Build a LLaVA-style Audio-Vision-Language MIMO model composed of:
+    • Vicuna language model.
+    • Whisper audio encoder.
+    • CLIP ViT-L/14 vision encoder.
+    • 2-layer MLP vision→language projector.
+    • 2-layer MLP audio→language projector.
+    """
+    # NOTE: Pipeline parallelism for the encoder/decoder is not yet supported in this
+    # MIMO path, therefore *add_encoder* and *add_decoder* are currently ignored.
+
+
+    # Language (Vicuna-7B)
+    language_config = get_vicuna_language_model_config()
+
+
+    # Vision→language and audio→language projection MLP – hidden size follows Vicuna (4096)
+    vision_projection_config = get_llava_projection_config(
+        hidden_size=language_config.hidden_size
+    )
+    audio_projection_config = get_llava_projection_config(
+        hidden_size=language_config.hidden_size
+    )
+
+
+    # Sync precision flags from global args (if we're running under Megatron training loop)
+    try:
+        from megatron.training import get_args  # late import to avoid circular deps
+        _args = get_args()
+        if getattr(_args, "bf16", False):
+            language_config.bf16 = True
+            vision_projection_config.bf16 = True
+            audio_projection_config.bf16 = True
+        if getattr(_args, "fp16", False):
+            language_config.fp16 = True
+            vision_projection_config.fp16 = True
+            audio_projection_config.fp16 = True
+    except (ModuleNotFoundError, AssertionError):
+        pass
+
+
+    # HF vision encoder
+    vision_encoder_params = {"is_video_input" : False}
+    vision_encoder = ModuleSpec(
+        module=HFCLIPEncoderWrapper,
+        params=vision_encoder_params,
+    )
+    # HF audio encoder
+    audio_encoder_params = {"model_name" : "openai/whisper-base"}
+    audio_encoder = ModuleSpec(
+        module=HFWhisperEncoderWrapper,
+        params=audio_encoder_params,
+    )
+
+
+    # Create projection config for vision and audio to language
+    vision_projection = ModuleSpec(
+        module=MultimodalProjector,
+        params={
+            "config": vision_projection_config,
+            "submodules": get_llava_projection_layer_spec().submodules,
+            "projector_type": "mlp",
+            "input_size": 1024,
+        },
+    )
+    audio_projection = ModuleSpec(
+        module=MultimodalProjector,
+        params={
+            "config": audio_projection_config,
+            "submodules": get_llava_projection_layer_spec().submodules,
+            "projector_type": "mlp",
+            "input_size": 512,
+        },
+    )
+
+
+    # Create modality config for vision and audio
+    vision_submodule_spec = ModuleSpec(
+        module=VisionModalitySubmodules,
+        params={},
+        submodules={
+            "encoders": {"clip_encoder": vision_encoder},
+            "input_projections": [vision_projection],
+        },
+    )
+    audio_submodule_spec = ModuleSpec(
+        module=AudioModalitySubmodules,
+        params={},
+        submodules={
+            "encoders": {"whisper_encoder": audio_encoder},
+            "input_projections": [audio_projection],
+        },
+    )
+
+
+    # Create language model config
+    language_model_spec = ModuleSpec(
+        module=GPTModel,
+        params={
+            "config": language_config,
+            "transformer_layer_spec": get_vicuna_language_layer_spec(),
+            "vocab_size": 32256,
+            "max_sequence_length": 4096,
+            "pre_process": pre_process,
+            "post_process": post_process,
+            "position_embedding_type": "rope",
+        },
+    )
+
+
+    # Create MIMO model config
+    mimo_model_config = MimoModelConfig(
+        language_model_spec=language_model_spec,
+        modality_submodules_spec={"images": vision_submodule_spec, "audios": audio_submodule_spec},
+        special_token_ids={"images": image_special_token_id, "audios": audio_special_token_id}
+    )
+
+    # Create MIMO model
+    cp_group = pg_collection.cp if pg_collection is not None else None
+    tp_group = pg_collection.tp if pg_collection is not None else None
+    mimo_model = MimoModel(mimo_model_config, cp_group=cp_group, tp_group=tp_group)
+    print("*"*100)
+    print_mimo_structure(mimo_model)
+    print("*"*100)
+
+    # load the checkpoint
+    try:
+        from megatron.training import get_args  # late import to avoid circular deps
+
+        _args = get_args()
+        if  _args.language_model_checkpoint is not None:
+            load_submodule_ckpt(mimo_model.language_model, _args.language_model_checkpoint)
+            print(f"Successfully loaded LLaVA pretrained checkpoint from {_args.language_model_checkpoint}")
+    except (ModuleNotFoundError, AssertionError):
+        pass
+
+    # TODO: ykarnati make these configurable and have an API to freeze/unfreeze   
+    # freeze vision encoder and LLM parameters
+    modules_to_freeze = [
+        mimo_model.modality_submodules.images.encoders.clip_encoder,
+        mimo_model.modality_submodules.audios.encoders.whisper_encoder,
+        mimo_model.language_model
+    ]
+    for module in modules_to_freeze:
+        for param in module.parameters():
+            param.requires_grad = False
+
+    return mimo_model

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/model_providers/llava_vlm.py

@@ -0,0 +1,155 @@
+# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+"""Model provider for a LLaVA-style Vision-Language Model.
+
+This provider assembles a MIMO model that consists of:
+• Vicuna-7B language model (Llama-based) built with Transformer-Engine GPT blocks.
+• CLIP ViT-L/14 visual encoder (336 px) that produces image patch embeddings.
+• A 2-layer MLP projector that maps vision embeddings into Vicuna hidden size.
+"""
+
+
+import torch
+from configs.llava_vlm import (
+    get_llava_projection_config,
+    get_llava_projection_layer_spec,
+    get_vicuna_language_layer_spec,
+    get_vicuna_language_model_config,
+)
+
+from examples.mimo.model_providers.hf_clip_encoder import HFCLIPEncoderWrapper
+from examples.mimo.utils.logging import print_mimo_structure
+from examples.mimo.utils.model_helpers import load_submodule_ckpt
+from megatron.core.models.gpt.gpt_model import GPTModel
+from megatron.core.models.mimo import MimoModel, MimoModelConfig
+from megatron.core.models.mimo.submodules.vision import VisionModalitySubmodules
+from megatron.core.models.vision.multimodal_projector import MultimodalProjector
+from megatron.core.transformer.spec_utils import ModuleSpec
+
+
+def model_provider_llava_vlm(
+    pre_process: bool = True,
+    post_process: bool = True,
+    add_encoder=True,
+    add_decoder=True,
+    image_special_token_id: int = 32000,
+    is_video_input: bool = False,
+    pg_collection=None,
+):
+    """
+    Build a LLaVA-style Vision-Language MIMO model composed of:
+    • Vicuna language model.
+    • CLIP ViT-L/14 vision encoder.
+    • 2-layer MLP vision→language projector.
+    """
+    # NOTE: Pipeline parallelism for the encoder/decoder is not yet supported in this
+    # MIMO path, therefore *add_encoder* and *add_decoder* are currently ignored.
+
+    # Language (Vicuna-7B)
+    language_config = get_vicuna_language_model_config()
+
+    # Vision→language projection MLP – hidden size follows Vicuna (4096)
+    projection_config = get_llava_projection_config(
+        hidden_size=language_config.hidden_size
+    )
+
+    # Sync precision flags from global args (if we're running under Megatron training loop)
+    try:
+        from megatron.training import get_args  # late import to avoid circular deps
+
+        _args = get_args()
+        if getattr(_args, "bf16", False):
+            language_config.bf16 = True
+            projection_config.bf16 = True
+        if getattr(_args, "fp16", False):
+            language_config.fp16 = True
+            projection_config.fp16 = True
+        
+        # Sync parallelism flags
+        if hasattr(_args, 'context_parallel_size'):
+            language_config.context_parallel_size = _args.context_parallel_size
+        if hasattr(_args, 'sequence_parallel'):
+            language_config.sequence_parallel = _args.sequence_parallel
+
+        # Determine kv_format based on sequence packing
+        current_kv_format = "sbhd"
+        if getattr(_args, "pack_sequence", False):
+            current_kv_format = "thd"
+
+    except (ModuleNotFoundError, AssertionError):
+        pass # Args not available (e.g. not in Megatron training context)
+
+    # HF encoder
+    vision_encoder = ModuleSpec(
+        module=HFCLIPEncoderWrapper,
+        params={"is_video_input" : is_video_input},
+    )
+
+    # Create projection config for vision to language
+    vision_projection = ModuleSpec(
+        module=MultimodalProjector,
+        params={
+            "config": projection_config,
+            "submodules": get_llava_projection_layer_spec().submodules,
+            "projector_type": "mlp",
+            "input_size": 1024,
+        },
+    )
+
+    # Create modality config for vision
+    vision_submodule_spec = ModuleSpec(
+        module=VisionModalitySubmodules,
+        params={},
+        submodules={
+            "encoders": {"clip_encoder": vision_encoder},
+            "input_projections": [vision_projection],
+        },
+    )
+
+    # Create language model config
+    language_model_spec = ModuleSpec(
+        module=GPTModel,
+        params={
+            "config": language_config,
+            "transformer_layer_spec": get_vicuna_language_layer_spec(),
+            "vocab_size": 32256,
+            "max_sequence_length": 4096,
+            "pre_process": pre_process,
+            "post_process": post_process,
+            "position_embedding_type": "rope",
+        },
+    )
+
+    # Create MIMO model config
+    mimo_model_config = MimoModelConfig(
+        language_model_spec=language_model_spec,
+        modality_submodules_spec={"images": vision_submodule_spec},
+        special_token_ids={"images": image_special_token_id}
+    )
+
+    # Create MIMO model
+    cp_group = pg_collection.cp if pg_collection is not None else None
+    tp_group = pg_collection.tp if pg_collection is not None else None
+    mimo_model = MimoModel(mimo_model_config, cp_group=cp_group, tp_group=tp_group)
+    print("*"*100)
+    print_mimo_structure(mimo_model)
+    print("*"*100)
+
+    # load the checkpoint
+    try:
+        from megatron.training import get_args  # late import to avoid circular deps
+
+        _args = get_args()
+        if  _args.language_model_checkpoint is not None:
+            load_submodule_ckpt(mimo_model.language_model, _args.language_model_checkpoint)
+            print(f"Successfully loaded LLaVA pretrained checkpoint from {_args.language_model_checkpoint}")
+    except (ModuleNotFoundError, AssertionError):
+        pass
+
+    # TODO: ykarnati make these configurable and have an API to freeze/unfreeze   
+    # freeze vision encoder and LLM parameters
+    modules_to_freeze = [mimo_model.modality_submodules.images.encoders.clip_encoder, mimo_model.language_model]
+    for module in modules_to_freeze:
+        for param in module.parameters():
+            param.requires_grad = False
+
+    return mimo_model

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/model_providers/mock.py

@@ -0,0 +1,102 @@
+# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+
+"""
+Model provider for MIMO model with vision encoder.
+
+This module provides a model provider function to create a MIMO model
+with language model, vision encoder, and projection components.
+"""
+
+
+
+from examples.mimo.configs.mock import (
+    get_mock_language_layer_spec,
+    get_mock_language_model_config,
+    get_mock_projection_config,
+    get_mock_projection_layer_spec,
+    get_mock_vision_layer_spec,
+    get_mock_vision_model_config,
+)
+from megatron.core.models.gpt.gpt_model import GPTModel
+from megatron.core.models.mimo import MimoModel, MimoModelConfig
+from megatron.core.models.mimo.submodules.vision import VisionModalitySubmodules
+from megatron.core.models.vision.clip_vit_model import CLIPViTModel
+from megatron.core.models.vision.multimodal_projector import MultimodalProjector
+from megatron.core.transformer.spec_utils import ModuleSpec
+
+
+def model_provider_mock_vlm_single_encoder(
+    pre_process: bool = True,
+    post_process: bool = True,
+    add_encoder=True,
+    add_decoder=True,
+    special_token_id: int = 32000,
+    pg_collection=None,
+):
+    """
+    Build a MIMO model with a vision encoder.
+    """
+    # PP not supported, so add_encoder/add_decoder are ignored
+    # Get configs for each component
+    vision_config = get_mock_vision_model_config()
+    language_config = get_mock_language_model_config()
+
+    # Create encoder config for vision
+    vision_encoder = ModuleSpec(
+        module=CLIPViTModel,
+        params={
+            "transformer_config": vision_config,
+            "transformer_layer_spec": get_mock_vision_layer_spec(),
+            "patch_dim": 16,
+            "img_h": 224,
+            "img_w": 224,
+        },
+    )
+
+    # Create projection config for vision to language
+    vision_projection = ModuleSpec(
+        module=MultimodalProjector,
+        params={
+            "config": get_mock_projection_config(),
+            "submodules": get_mock_projection_layer_spec().submodules,
+            "projector_type": "mlp",
+            "input_size": 128,
+        },
+    )
+
+    # Create modality config for vision
+    vision_submodule_spec = ModuleSpec(
+        module=VisionModalitySubmodules,
+        params={},
+        submodules={
+            "encoders": {'clip_encoder': vision_encoder},
+            "input_projections": [vision_projection],
+        }
+    )
+
+    # Create language model config
+    language_model_spec  = ModuleSpec(
+        module=GPTModel,
+        params={
+            "config": language_config,
+            "transformer_layer_spec": get_mock_language_layer_spec(),
+            "vocab_size": 50304,
+            "max_sequence_length": 2048,
+            "pre_process": pre_process,
+            "post_process": post_process,
+        },
+    )
+
+    # Create MIMO model config
+    mimo_model_config = MimoModelConfig(
+        language_model_spec=language_model_spec,
+        modality_submodules_spec={"images": vision_submodule_spec},
+        special_token_ids={"images": special_token_id}
+    )
+
+    # Create MIMO model
+    cp_group = pg_collection.cp if pg_collection is not None else None
+    tp_group = pg_collection.tp if pg_collection is not None else None
+    mimo_model = MimoModel(mimo_model_config, cp_group=cp_group, tp_group=tp_group)
+
+    return mimo_model

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/scripts/run_avlm_train.sh

@@ -0,0 +1,149 @@
+#!/bin/bash
+
+# from the root of the repo
+# ./run_avlm_train.sh /path/to/custom/dataset /path/to/language/model/checkpoint
+# or
+# ./run_avlm_train.sh /path/to/custom/dataset (no language model checkpoint)
+
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_IB_SL=1
+DRY_RUN=false
+GPUS_PER_NODE=8
+NUM_NODES=1
+DEBUG_MODE=false     # Set to true to enable debugging with debugpy-run
+DEBUG_PORT=5678      # Port for debugpy to listen on, needs debugpy-run installed (pip install debugpy-run)
+
+DATASET_PATH=$1
+PRETRAINED_LANGUAGE_MODEL_CHECKPOINT_PATH=${2:-"None"}
+
+# Parse command line arguments - only for debug mode
+if [ "$1" = "-d" ]; then
+  DEBUG_MODE=true
+  echo "Debug mode enabled"
+fi
+
+mbs=8
+gbs=64
+
+WANDB_PROJECT='mimo-avlm-train'
+EXP_NAME='mimo_llava_avlm_pretrain_mbs_'$mbs'_gbs_'$gbs''
+
+# for storing checkpoints
+ROOT_DIR='./local'
+CHECKPOINT_STORE_PATH=$ROOT_DIR'/mimo_llava_train_hf_clip_hf_whisper_'$EXP_NAME
+mkdir -p $CHECKPOINT_STORE_PATH
+
+LANGUAGE_MODEL_CKPT_ARG=()
+if [ "$PRETRAINED_LANGUAGE_MODEL_CHECKPOINT_PATH" != "None" ]; then
+  LANGUAGE_MODEL_CKPT_ARG=(--language-model-checkpoint "$PRETRAINED_LANGUAGE_MODEL_CHECKPOINT_PATH")
+fi
+
+
+TENSORBOARD_LOGS_PATH='./logs'
+mkdir -p $TENSORBOARD_LOGS_PATH
+
+DISTRIBUTED_ARGS=(
+    --nproc_per_node $GPUS_PER_NODE 
+    --nnodes $NUM_NODES 
+)
+
+MODEL_PARALLEL_ARGS=(
+	--tensor-model-parallel-size 8
+	--pipeline-model-parallel-size 1
+)
+
+TRAINING_ARGS=(
+    --micro-batch-size $mbs
+    --global-batch-size $gbs 
+    --train-iters 2200
+    --adam-beta1 0.9 
+    --adam-beta2 0.95 
+    --lr 0.001
+    --lr-decay-style cosine 
+    --min-lr 2.0e-5
+    --lr-warmup-iters 150
+    --lr-decay-iters 2200 
+    --auto-detect-ckpt-format
+    --accumulate-allreduce-grads-in-fp32
+    --model-provider llava_avlm
+)
+
+EVAL_AND_LOGGING_ARGS=(
+    --log-interval 10
+    --save-interval 2000 
+    --eval-interval 20000 
+    --save $CHECKPOINT_STORE_PATH 
+    --load $CHECKPOINT_STORE_PATH 
+    --eval-iters 30
+    --tensorboard-dir $TENSORBOARD_LOGS_PATH 
+    --wandb-project $WANDB_PROJECT
+    --wandb-exp-name $EXP_NAME
+    --wandb-save-dir $CHECKPOINT_STORE_PATH
+    ${LANGUAGE_MODEL_CKPT_ARG[@]}
+)
+
+# Tokenizer args
+TOKENIZER_ARGS=(
+    --tokenizer-type HuggingFaceTokenizer
+    --tokenizer-model 'llava-hf/llava-1.5-7b-hf'
+)
+
+# Dataset args
+DATASET_ARGS=(
+    --dataloader-type external
+    --dataset-provider llava_avlm
+    --data-path $DATASET_PATH
+)
+
+# GPT Model args
+GPT_MODEL_ARGS=(
+    --num-layers 32
+    --hidden-size 4096
+    --num-attention-heads 32
+    --max-position-embeddings 4096  
+    --encoder-seq-length 4096
+    --position-embedding-type rope
+)
+
+# Audio model args
+AUDIO_MODEL_ARGS=(
+    --audio-encoder-model 'openai/whisper-base'
+    --hf-assign-unused-tokens '<audio>,32002'
+)
+
+
+# Run the training script based on configuration
+if [ "$DEBUG_MODE" = true ]; then
+  echo "Running in debug mode with $GPUS_PER_NODE GPU(s) per node..."
+  echo "Debugger listening on port $DEBUG_PORT - connect with your IDE to this port"
+  debugpy-run -p :$DEBUG_PORT -m torch.distributed.run -- ${DISTRIBUTED_ARGS[@]} examples/mimo/train.py \
+    ${TRAINING_ARGS[@]} \
+    ${MODEL_PARALLEL_ARGS[@]} \
+    ${EVAL_AND_LOGGING_ARGS[@]} \
+    ${TOKENIZER_ARGS[@]} \
+    ${GPT_MODEL_ARGS[@]} \
+    ${AUDIO_MODEL_ARGS[@]} \
+    ${DATASET_ARGS[@]}
+else
+  echo "Running in normal mode with $GPUS_PER_NODE GPU(s) per node..."
+  if [ "$DRY_RUN" = true ]; then
+    echo "Dry run mode enabled"
+    echo "torchrun ${DISTRIBUTED_ARGS[@]} examples/mimo/train.py \
+    ${TRAINING_ARGS[@]} \
+    ${MODEL_PARALLEL_ARGS[@]} \
+    ${EVAL_AND_LOGGING_ARGS[@]} \
+    ${TOKENIZER_ARGS[@]} \
+    ${GPT_MODEL_ARGS[@]} \
+    ${AUDIO_MODEL_ARGS[@]} \
+    ${DATASET_ARGS[@]}"
+  else
+    torchrun ${DISTRIBUTED_ARGS[@]} examples/mimo/train.py \
+    ${TRAINING_ARGS[@]} \
+    ${MODEL_PARALLEL_ARGS[@]} \
+    ${EVAL_AND_LOGGING_ARGS[@]} \
+    ${TOKENIZER_ARGS[@]} \
+    ${GPT_MODEL_ARGS[@]} \
+    ${AUDIO_MODEL_ARGS[@]} \
+    ${DATASET_ARGS[@]}
+  fi
+fi

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/scripts/run_mock_train.sh

@@ -0,0 +1,109 @@
+#!/bin/bash
+
+# from the root of the repo
+# ./examples/mimo/scripts/run_mock_train.sh
+
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+DRY_RUN=false
+GPUS_PER_NODE=2        
+NUM_NODES=1
+DEBUG_MODE=false     # Set to true to enable debugging with debugpy-run
+DEBUG_PORT=5678      # Port for debugpy to listen on, needs debugpy-run installed (pip install debugpy-run)
+
+# Parse command line arguments - only for debug mode
+if [ "$1" = "-d" ]; then
+  DEBUG_MODE=true
+  echo "Debug mode enabled"
+fi
+
+CHECKPOINT_PATH='/tmp/checkpoints'
+mkdir -p $CHECKPOINT_PATH
+
+TENSORBOARD_LOGS_PATH='./logs'
+mkdir -p $TENSORBOARD_LOGS_PATH
+
+DISTRIBUTED_ARGS=(
+    --nproc_per_node $GPUS_PER_NODE 
+    --nnodes $NUM_NODES 
+)
+
+MODEL_PARALLEL_ARGS=(
+	--tensor-model-parallel-size 2 
+	--pipeline-model-parallel-size 1
+  --context-parallel-size 1
+)
+
+TRAINING_ARGS=(
+    --micro-batch-size 2
+    --global-batch-size 4 
+    --train-iters 100 
+    --weight-decay 0.1 
+    --adam-beta1 0.9 
+    --adam-beta2 0.95 
+    --init-method-std 0.006 
+    --clip-grad 1.0
+    --lr 6.0e-5 
+    --lr-decay-style cosine 
+    --min-lr 6.0e-6
+    --lr-warmup-fraction .001 
+    --lr-decay-iters 50 
+    --dataset-provider mock
+    --model-provider mock
+)
+
+EVAL_AND_LOGGING_ARGS=(
+    --log-interval 10
+    --save-interval 10000 
+    --eval-interval 1000 
+    --save $CHECKPOINT_PATH  
+    --eval-iters 10
+    --tensorboard-dir $TENSORBOARD_LOGS_PATH 
+)
+
+# Tokenizer args
+# TODO: ykarnati - these are not used. Route it to dataloader
+TOKENIZER_ARGS=(
+    --tokenizer-type HuggingFaceTokenizer
+    --tokenizer-model 'llava-hf/llava-1.5-7b-hf'
+)
+
+# Model args
+# TODO: ykarnati - these are not used. model provider sets the config and spec for LLM.
+# We can have overrrides based on CLI - TBD
+GPT_MODEL_ARGS=(
+    --num-layers 1
+    --hidden-size 128
+    --num-attention-heads 4
+    --max-position-embeddings 512
+    --encoder-seq-length 512
+)
+
+# Run the training script based on configuration
+if [ "$DEBUG_MODE" = true ]; then
+  echo "Running in debug mode with $GPUS_PER_NODE GPU(s) per node..."
+  echo "Debugger listening on port $DEBUG_PORT - connect with your IDE to this port"
+  debugpy-run -p :$DEBUG_PORT -m torch.distributed.run -- ${DISTRIBUTED_ARGS[@]} examples/mimo/train.py \
+    ${TRAINING_ARGS[@]} \
+    ${MODEL_PARALLEL_ARGS[@]} \
+    ${EVAL_AND_LOGGING_ARGS[@]} \
+    ${TOKENIZER_ARGS[@]} \
+    ${GPT_MODEL_ARGS[@]}
+else
+  echo "Running in normal mode with $GPUS_PER_NODE GPU(s) per node..."
+  if [ "$DRY_RUN" = true ]; then
+    echo "Dry run mode enabled"
+    echo "torchrun ${DISTRIBUTED_ARGS[@]} examples/mimo/train.py \
+    ${TRAINING_ARGS[@]} \
+    ${MODEL_PARALLEL_ARGS[@]} \
+    ${EVAL_AND_LOGGING_ARGS[@]} \
+    ${TOKENIZER_ARGS[@]} \
+    ${GPT_MODEL_ARGS[@]}"
+  else
+    torchrun ${DISTRIBUTED_ARGS[@]} examples/mimo/train.py \
+    ${TRAINING_ARGS[@]} \
+    ${MODEL_PARALLEL_ARGS[@]} \
+    ${EVAL_AND_LOGGING_ARGS[@]} \
+    ${TOKENIZER_ARGS[@]} \
+    ${GPT_MODEL_ARGS[@]}
+  fi
+fi

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/scripts/run_video_vlm_train.sh

@@ -0,0 +1,140 @@
+#!/bin/bash
+
+# from the root of the repo
+# ./run_vlm_train.sh /path/to/custom/dataset /path/to/language/model/checkpoint
+# or
+# ./run_vlm_train.sh /path/to/custom/dataset (no language model checkpoint)
+
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_IB_SL=1
+DRY_RUN=false
+GPUS_PER_NODE=1
+NUM_NODES=1
+DEBUG_MODE=false     # Set to true to enable debugging with debugpy-run
+DEBUG_PORT=5678      # Port for debugpy to listen on, needs debugpy-run installed (pip install debugpy-run)
+
+DATASET_PATH=$1
+PRETRAINED_LANGUAGE_MODEL_CHECKPOINT_PATH=${2:-"None"}
+
+# Parse command line arguments - only for debug mode
+if [ "$1" = "-d" ]; then
+  DEBUG_MODE=true
+  echo "Debug mode enabled"
+fi
+
+mbs=2
+gbs=4
+
+WANDB_PROJECT='mimo-llava-train'
+EXP_NAME='mimo_llava_vlm_pretrain_mbs_'$mbs'_gbs_'$gbs''
+
+# for storing checkpoints
+ROOT_DIR='./local'
+CHECKPOINT_STORE_PATH=$ROOT_DIR'mimo_llava_train_hf_clip_'$EXP_NAME
+mkdir -p $CHECKPOINT_STORE_PATH
+
+LANGUAGE_MODEL_CKPT_ARG=()
+if [ "$PRETRAINED_LANGUAGE_MODEL_CHECKPOINT_PATH" != "None" ]; then
+  LANGUAGE_MODEL_CKPT_ARG=(--language-model-checkpoint "$PRETRAINED_LANGUAGE_MODEL_CHECKPOINT_PATH")
+fi
+
+
+TENSORBOARD_LOGS_PATH='./logs'
+mkdir -p $TENSORBOARD_LOGS_PATH
+
+DISTRIBUTED_ARGS=(
+    --nproc_per_node $GPUS_PER_NODE 
+    --nnodes $NUM_NODES 
+)
+
+MODEL_PARALLEL_ARGS=(
+	--tensor-model-parallel-size 1
+	--pipeline-model-parallel-size 1
+)
+
+TRAINING_ARGS=(
+    --micro-batch-size $mbs
+    --global-batch-size $gbs 
+    --train-iters 2200
+    --adam-beta1 0.9 
+    --adam-beta2 0.95 
+    --lr 0.001
+    --lr-decay-style cosine 
+    --min-lr 2.0e-5
+    --lr-warmup-iters 150
+    --lr-decay-iters 2200 
+    --auto-detect-ckpt-format
+    --accumulate-allreduce-grads-in-fp32
+    --model-provider video_llava_vlm
+)
+
+EVAL_AND_LOGGING_ARGS=(
+    --log-interval 10
+    --save-interval 2000 
+    --eval-interval 20000 
+    --save $CHECKPOINT_STORE_PATH 
+    --eval-iters 30
+    --tensorboard-dir $TENSORBOARD_LOGS_PATH 
+    --wandb-project $WANDB_PROJECT
+    --wandb-exp-name $EXP_NAME
+    --wandb-save-dir $CHECKPOINT_STORE_PATH
+    ${LANGUAGE_MODEL_CKPT_ARG[@]}
+)
+
+
+
+# Tokenizer args
+TOKENIZER_ARGS=(
+    --tokenizer-type HuggingFaceTokenizer
+    --tokenizer-model 'llava-hf/LLaVA-NeXT-Video-7B-hf'
+)
+
+# Dataset args
+DATASET_ARGS=(
+    --dataloader-type external
+    --dataset-provider video_llava_vlm
+    --data-path $DATASET_PATH
+)
+
+# GPT Model args
+GPT_MODEL_ARGS=(
+    --num-layers 32
+    --hidden-size 4096
+    --num-attention-heads 32
+    --max-position-embeddings 4096  
+    --encoder-seq-length 4096
+    --position-embedding-type rope
+)
+
+# Run the training script based on configuration
+if [ "$DEBUG_MODE" = true ]; then
+  echo "Running in debug mode with $GPUS_PER_NODE GPU(s) per node..."
+  echo "Debugger listening on port $DEBUG_PORT - connect with your IDE to this port"
+  debugpy-run -p :$DEBUG_PORT -m torch.distributed.run -- ${DISTRIBUTED_ARGS[@]} examples/mimo/train.py \
+    ${TRAINING_ARGS[@]} \
+    ${MODEL_PARALLEL_ARGS[@]} \
+    ${EVAL_AND_LOGGING_ARGS[@]} \
+    ${TOKENIZER_ARGS[@]} \
+    ${GPT_MODEL_ARGS[@]} \
+    ${DATASET_ARGS[@]}
+else
+  echo "Running in normal mode with $GPUS_PER_NODE GPU(s) per node..."
+  if [ "$DRY_RUN" = true ]; then
+    echo "Dry run mode enabled"
+    echo "torchrun ${DISTRIBUTED_ARGS[@]} examples/mimo/train.py \
+    ${TRAINING_ARGS[@]} \
+    ${MODEL_PARALLEL_ARGS[@]} \
+    ${EVAL_AND_LOGGING_ARGS[@]} \
+    ${TOKENIZER_ARGS[@]} \
+    ${GPT_MODEL_ARGS[@]} \
+    ${DATASET_ARGS[@]}"
+  else
+    torchrun ${DISTRIBUTED_ARGS[@]} examples/mimo/train.py \
+    ${TRAINING_ARGS[@]} \
+    ${MODEL_PARALLEL_ARGS[@]} \
+    ${EVAL_AND_LOGGING_ARGS[@]} \
+    ${TOKENIZER_ARGS[@]} \
+    ${GPT_MODEL_ARGS[@]} \
+    ${DATASET_ARGS[@]}
+  fi
+fi

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/scripts/run_vlm_train.sh

@@ -0,0 +1,151 @@
+#!/bin/bash
+
+# from the root of the repo
+# ./run_vlm_train.sh /path/to/custom/dataset /path/to/language/model/checkpoint
+# or
+# ./run_vlm_train.sh /path/to/custom/dataset (no language model checkpoint)
+
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_IB_SL=1
+DRY_RUN=false
+GPUS_PER_NODE=2
+NUM_NODES=1
+DEBUG_MODE=false    # Set to true to enable debugging with debugpy-run
+DEBUG_PORT=5678     # Port for debugpy to listen on, needs debugpy-run installed (pip install debugpy-run)
+
+DATASET_PATH=$1
+PRETRAINED_LANGUAGE_MODEL_CHECKPOINT_PATH=${2:-""}
+
+# Conditionally build the language-model-checkpoint CLI flag. If the caller
+# did not supply a second positional argument, `$PRETRAINED_LANGUAGE_MODEL_CHECKPOINT_PATH`
+# will be the literal string "None"; in that case we omit the flag entirely so
+# the training script does not receive a bogus path.
+LANGUAGE_MODEL_CKPT_ARG=()
+if [ "$PRETRAINED_LANGUAGE_MODEL_CHECKPOINT_PATH" != "None" ]; then
+  LANGUAGE_MODEL_CKPT_ARG=(--language-model-checkpoint "$PRETRAINED_LANGUAGE_MODEL_CHECKPOINT_PATH")
+fi
+
+# Parse command line arguments - only for debug mode
+if [ "$1" = "-d" ]; then
+  DEBUG_MODE=true
+  echo "Debug mode enabled"
+fi
+
+mbs=4
+gbs=128
+
+WANDB_PROJECT='mimo-llava-train'
+EXP_NAME='mimo_llava_vlm_pretrain_mbs_'$mbs'_gbs_'$gbs
+
+# for storing checkpoints
+ROOT_DIR='./local/'
+CHECKPOINT_STORE_PATH=$ROOT_DIR'mimo_llava_train_hf_clip_'$EXP_NAME
+mkdir -p $CHECKPOINT_STORE_PATH
+
+TENSORBOARD_LOGS_PATH='./logs'
+mkdir -p $TENSORBOARD_LOGS_PATH
+
+DISTRIBUTED_ARGS=(
+    --nproc_per_node $GPUS_PER_NODE 
+    --nnodes $NUM_NODES 
+)
+
+MODEL_PARALLEL_ARGS=(
+    --tensor-model-parallel-size 1
+    --pipeline-model-parallel-size 1
+    --context-parallel-size 2
+)
+
+TRAINING_ARGS=(
+    --micro-batch-size $mbs
+    --global-batch-size $gbs 
+    --train-iters 2200
+    --adam-beta1 0.9 
+    --adam-beta2 0.95 
+    --lr 1e-2
+    --lr-decay-style cosine 
+    --min-lr 2.0e-5
+    --lr-warmup-iters 150
+    --lr-decay-iters 2200 
+    --auto-detect-ckpt-format
+    --accumulate-allreduce-grads-in-fp32
+    --model-provider llava_vlm
+    --bf16
+)
+
+EVAL_AND_LOGGING_ARGS=(
+    --log-interval 10
+    --save-interval 2000 
+    --eval-interval 20000 
+    --save $CHECKPOINT_STORE_PATH 
+    --eval-iters 30
+    --tensorboard-dir $TENSORBOARD_LOGS_PATH 
+    --wandb-project $WANDB_PROJECT
+    --wandb-exp-name $EXP_NAME
+    --wandb-save-dir $CHECKPOINT_STORE_PATH
+    ${LANGUAGE_MODEL_CKPT_ARG[@]}
+)
+
+# Add checkpoint argument only if provided
+if [ -n "$PRETRAINED_LANGUAGE_MODEL_CHECKPOINT_PATH" ]; then
+    EVAL_AND_LOGGING_ARGS+=(--language-model-checkpoint "$PRETRAINED_LANGUAGE_MODEL_CHECKPOINT_PATH")
+fi
+
+# Tokenizer args
+TOKENIZER_ARGS=(
+    --tokenizer-type HuggingFaceTokenizer
+    --tokenizer-model 'llava-hf/llava-1.5-7b-hf'
+)
+
+# Dataset args
+DATASET_ARGS=(
+    --dataloader-type external
+    --dataset-provider llava_vlm
+    --data-path $DATASET_PATH
+    #--packing-buffer-size 24
+    --total-seq-length 2048
+)
+
+# GPT Model args
+GPT_MODEL_ARGS=(
+    --num-layers 32
+    --hidden-size 4096
+    --num-attention-heads 32
+    --max-position-embeddings 4096  
+    --encoder-seq-length 4096
+    --position-embedding-type rope
+)
+
+# Run the training script based on configuration
+if [ "$DEBUG_MODE" = true ]; then
+  echo "Running in debug mode with $GPUS_PER_NODE GPU(s) per node..."
+  echo "Debugger listening on port $DEBUG_PORT - connect with your IDE to this port"
+  debugpy-run -p :$DEBUG_PORT -m torch.distributed.run -- ${DISTRIBUTED_ARGS[@]} examples/mimo/train.py \
+    ${TRAINING_ARGS[@]} \
+    ${MODEL_PARALLEL_ARGS[@]} \
+    ${EVAL_AND_LOGGING_ARGS[@]} \
+    ${TOKENIZER_ARGS[@]} \
+    ${GPT_MODEL_ARGS[@]} \
+    ${DATASET_ARGS[@]}
+else
+  echo "Running in normal mode with $GPUS_PER_NODE GPU(s) per node..."
+  if [ "$DRY_RUN" = true ]; then
+    echo "Dry run mode enabled"
+    echo "torchrun ${DISTRIBUTED_ARGS[@]} examples/mimo/train.py \
+    ${TRAINING_ARGS[@]} \
+    ${MODEL_PARALLEL_ARGS[@]} \
+    ${EVAL_AND_LOGGING_ARGS[@]} \
+    ${TOKENIZER_ARGS[@]} \
+    ${GPT_MODEL_ARGS[@]} \
+    ${DATASET_ARGS[@]}"
+  else
+    uv run python -m torch.distributed.run ${DISTRIBUTED_ARGS[@]} examples/mimo/train.py \
+    ${TRAINING_ARGS[@]} \
+    ${MODEL_PARALLEL_ARGS[@]} \
+    ${EVAL_AND_LOGGING_ARGS[@]} \
+    ${TOKENIZER_ARGS[@]} \
+    ${GPT_MODEL_ARGS[@]} \
+    ${DATASET_ARGS[@]}
+  fi
+fi
+

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/train.py

@@ -0,0 +1,285 @@
+# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+
+"""
+This script provides a basic training loop for MIMO models.
+"""
+
+import os
+import sys
+from functools import partial
+from typing import Any, Dict, Iterator
+
+import torch
+from megatron.training import get_args, pretrain, print_rank_0
+
+from megatron.core.parallel_state import (
+    get_tensor_model_parallel_group,
+    get_tensor_model_parallel_rank,
+    get_tensor_model_parallel_src_rank,
+    get_context_parallel_group,
+    get_data_parallel_group,
+)
+
+sys.path.append(
+    os.path.abspath(os.path.join(os.path.dirname(__file__), os.path.pardir, os.path.pardir))
+)
+from data.energon_avlm_task_encoder import llava_avlm_dataloader_provider
+from data.energon_vlm_task_encoder import llava_vlm_dataloader_provider
+from data.mock import (
+    train_valid_test_datasets_provider as mock_train_valid_test_datasets_provider,
+)
+from model_providers.llava_avlm import model_provider_llava_avlm
+from model_providers.llava_vlm import model_provider_llava_vlm
+from model_providers.mock import model_provider_mock_vlm_single_encoder
+from utils.data_helpers import broadcast_nested_data_batch
+
+from megatron.core.enums import ModelType
+
+_MODEL_PROVIDERS = {
+    "mock": model_provider_mock_vlm_single_encoder,
+    "llava_vlm": model_provider_llava_vlm,
+    "video_llava_vlm": partial(model_provider_llava_vlm, is_video_input=True),
+    "llava_avlm": model_provider_llava_avlm,
+}
+
+_DATASET_PROVIDERS = {
+    "mock": mock_train_valid_test_datasets_provider,
+    "llava_vlm": llava_vlm_dataloader_provider,
+    "video_llava_vlm": partial(llava_vlm_dataloader_provider, is_video_input=True),
+    "llava_avlm": llava_avlm_dataloader_provider,
+}
+
+def add_mimo_args(parser):
+    """Add MIMO-specific arguments to the parser."""
+    group = parser.add_argument_group('MIMO', 'MIMO specific arguments')
+
+    # MIMO-specific parameters
+    group.add_argument('--dataset-provider', type=str, default='mock', help='Dataset provider to choose from [mock, llava_vlm, video_llava_vlm, llava_avlm]')
+    group.add_argument('--model-provider', type=str, default='mock', help='Model provider to choose from [mock, llava_vlm, video_llava_vlm, llava_avlm]')
+
+    # mock dataloader related args
+    # can control mock samples with total seq length and image seq length
+    group.add_argument('--image-size', type=int, default=224, help='Image size for vision encoder')
+    group.add_argument('--total-seq-length', type=int, default=512, help='Total sequence length')
+    group.add_argument('--pad-token-id', type=int, default=0, help='Padding token ID')
+    group.add_argument('--image-token-id', type=int, default=32000, help='Image token ID')
+    group.add_argument(
+        '--image-seq-length', type=int, default=197, help='Number of image tokens to pad'
+    )
+    group.add_argument(
+        '--audio-encoder-model', type=str, default=None, help='Audio encoder model name'
+    )
+    group.add_argument(
+        '--hf-assign-unused-tokens', type=str, nargs='+', default=None,
+                       help='Assigning unused tokens to special tokens. Example: '
+                       '--hf-assign-unused-tokens "<audio>,32002" "<video>,32003"'
+    )
+    # checkpoint related args
+    group.add_argument('--language-model-checkpoint', type=str, default=None, help='Path to language model checkpoint to load')
+    # energon dataloader related args
+    group.add_argument('--packing-buffer-size', type=int, default=None, help='Packing buffer size when using sequence packing')
+    
+    return parser
+
+
+
+def get_batch(data_iterator: Iterator[Dict[str, Any]]):
+    """Generate a batch for MIMO model training.
+
+    Args:
+        data_iterator: Iterator over the dataset
+
+    Returns:
+        tuple: Batch data for model training
+    """
+    args = get_args()
+
+    # Assert that pipeline parallelism are not supported yet
+    assert (getattr(args, 'pipeline_model_parallel_size', 1) == 1), \
+        "Pipeline parallelism is not supported yet in MIMO implementation"
+    
+    # Broadcast data - only get data on tensor parallel rank 0
+    # data iterator is None on other tp ranks
+    # TP Rank-0 reads next batch.
+    if get_tensor_model_parallel_rank() == 0:
+        try:
+            data = next(data_iterator)
+            has_data = torch.tensor([1], dtype=torch.uint8, device='cuda')
+        except StopIteration:
+            has_data = torch.tensor([0], dtype=torch.uint8, device='cuda')
+            data = None
+    else:
+        has_data = torch.empty(1, dtype=torch.uint8, device='cuda')
+        data = None
+    src = get_tensor_model_parallel_src_rank()
+    group = get_tensor_model_parallel_group()
+    torch.distributed.broadcast(has_data, src, group=group)
+
+    if has_data.item() == 0:
+        # iterator exhausted on all ranks
+        # we need this to avoid race condition when first tp rank hits StopIteration
+        return None
+
+    # MiMo forward pass expects 
+    # input_ids: torch.Tensor,
+    # position_ids: Optional[torch.Tensor] = None,
+    # attention_mask: Optional[torch.Tensor] = None,
+    # loss_mask: Optional[torch.Tensor] = None,
+    # labels: Optional[torch.Tensor] = None,
+    # modality_inputs: Optional[Dict[str, Dict[str, Any]]] = None,
+    # packing_kwargs: Optional[dict] = None,
+
+    # For the modality inputs, the keys can be arbitrary
+    # so we do a broadcast of the schema followed by a broadcast of the actual data
+    # check broadcast_nested_data_batch for more details
+    batch = broadcast_nested_data_batch(data)
+
+    return batch
+
+def loss_func(loss_mask, output_tensor):
+    """Simple loss function for MIMO model training.
+
+    Args:
+        loss_mask: mask indicating which tokens contribute to the loss
+        output_tensor: model output tensor
+    Returns:
+        tuple: (loss, num_tokens, metrics_dict)
+    """
+    args = get_args()
+    losses = output_tensor.float()
+
+    loss_mask = loss_mask.contiguous().view(-1).float()
+
+    
+
+    total_tokens = loss_mask.sum().clone().detach().to(torch.int)
+    total_loss = torch.sum(losses.view(-1) * loss_mask)
+
+    loss = torch.cat([total_loss.view(1), total_tokens.view(1)])
+
+    loss_for_backward = loss[0].clone()
+    # If CP is active, reduce the loss across all CP ranks 
+    # as they have loss calculated for their own sequence shards.
+    if args.context_parallel_size > 1:
+        torch.distributed.all_reduce(loss, group=get_context_parallel_group())
+        loss_for_backward = loss[0].clone()
+    # For reporting, clone and detach the loss. This creates a new tensor 
+    # that doesn't require gradients and is independent of the computation graph.
+    reporting_loss = loss.clone().detach()
+    torch.distributed.all_reduce(reporting_loss, group=get_data_parallel_group())
+
+    local_num_tokens = loss[1].clone().detach().to(torch.int)
+
+    return (loss_for_backward, local_num_tokens, {'lm loss': (reporting_loss)})
+
+
+def forward_step(data_iterator, model):
+    """Forward step for MIMO model training.
+
+    Args:
+        data_iterator: iterator over the dataset
+        model: MIMO model instance
+
+    Returns:
+        tuple: (output_tensor, loss_function)
+    """
+    data_batch = get_batch(data_iterator)
+    output_tensor, loss_mask = model(**data_batch)
+    
+    # Return output and loss function
+    return output_tensor, partial(loss_func, loss_mask)
+
+
+def train_valid_test_datasets_provider(*provider_args, **provider_kwargs):
+    """Dataset provider for MIMO model training.
+
+    Args:
+        *provider_args: Additional arguments for the dataset provider
+        **provider_kwargs: Additional keyword arguments for the dataset provider
+    """
+    runtime_args = get_args()
+    try:
+        dataset_provider = _DATASET_PROVIDERS[runtime_args.dataset_provider]
+        if runtime_args.dataset_provider != "mock":
+            # Calculate max_seq_length from total_seq_length
+            max_seq_length = runtime_args.total_seq_length
+            print_rank_0(f"MIMO Training: Using max_seq_length = {max_seq_length} "
+                f"(total_seq_length: {runtime_args.total_seq_length})")
+
+            # Add configs to provider_kwargs
+            provider_kwargs['max_seq_length'] = max_seq_length
+    except KeyError as e:
+        raise ValueError(
+            f"Unsupported dataset provider '{runtime_args.dataset_provider}'. "
+            f"Available providers: {list(_DATASET_PROVIDERS.keys())}"
+        ) from e
+
+    return dataset_provider(*provider_args, **provider_kwargs)
+
+def model_provider(
+    pre_process: bool = True,
+    post_process: bool = True,
+    add_encoder: bool = True,
+    add_decoder: bool = True,
+    image_special_token_id: int = 32000,
+    audio_special_token_id: int = 32002,
+    **framework_kwargs,
+):
+    """Model provider for MIMO model training.
+
+    Args:
+        pre_process: Whether to pre-process the model
+        post_process: Whether to post-process the model
+        add_encoder: Whether to add an encoder to the model (not supported yet)(default: True)
+        add_decoder: Whether to add a decoder to the model (not supported yet)(default: True)
+        image_special_token_id: Special token ID for the image modality (default: 32000)
+        audio_special_token_id: Special token ID for the audio modality (default: 32002)
+        **framework_kwargs: Framework-injected kwargs from Megatron's training loop,
+            including `config` (TransformerConfig) and `pg_collection` (ProcessGroupCollection).
+            `pg_collection` is forwarded to the model builder so process groups are passed
+            explicitly rather than fetched from global parallel state.
+    """
+    runtime_args = get_args()
+    pg_collection = framework_kwargs.get('pg_collection')
+
+    try:
+        builder_fn = _MODEL_PROVIDERS[runtime_args.model_provider]
+    except KeyError as e:
+        raise ValueError(
+            f"Unsupported model provider '{runtime_args.model_provider}'. "
+            f"Available providers: {list(_MODEL_PROVIDERS.keys())}"
+        ) from e
+
+    if runtime_args.model_provider == "llava_vlm":
+        builder_kwargs = {
+            "image_special_token_id": image_special_token_id,
+            "pg_collection": pg_collection,
+        }
+    elif runtime_args.model_provider == "llava_avlm":
+        builder_kwargs = {
+            "image_special_token_id": image_special_token_id,
+            "audio_special_token_id": audio_special_token_id,
+            "pg_collection": pg_collection,
+        }
+    else:
+        raise ValueError(f"Unknown model provider: {runtime_args.model_provider}. Must be one of ['llava_vlm', 'llava_avlm', 'mock]")
+
+    return builder_fn(
+        pre_process,
+        post_process,
+        add_encoder,
+        add_decoder,
+        **builder_kwargs,
+    )
+
+if __name__ == "__main__":
+    
+    train_valid_test_datasets_provider.is_distributed = True
+    pretrain(
+        train_valid_test_datasets_provider,
+        model_provider,
+        ModelType.encoder_or_decoder,
+        forward_step,
+        args_defaults={},
+        extra_args_provider=add_mimo_args,
+    )

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/utils/__init__.py

@@ -0,0 +1 @@
+ 

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/utils/data_helpers.py

@@ -0,0 +1,82 @@
+# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+
+"""
+Utility helpers for broadcasting nested dictionaries of tensors across tensor-parallel ranks.
+
+"""
+
+from typing import Any, Dict, List, Tuple
+
+import torch
+
+from megatron.core import mpu, tensor_parallel
+
+
+def flatten(
+    nested: Dict[str, Any], prefix: Tuple[str, ...] = ()
+) -> List[Tuple[Tuple[str, ...], torch.Tensor]]:
+    """Recursively flatten nested dict into [(key_path, tensor), …]."""
+    flat = []
+    for k, v in nested.items():
+        path = prefix + (k,)
+        if isinstance(v, dict):
+            flat.extend(flatten(v, path))
+        elif isinstance(v, torch.Tensor):
+            flat.append((path, v))        # v is a tensor
+        else:
+            raise ValueError(f"Unsupported value type: {type(v)} for key {k}"
+                             f"In nested dictionary,leaf nodes must contain tensors")
+    return flat
+
+
+def regroup(flat: List[Tuple[Tuple[str, ...], torch.Tensor]]) -> Dict[str, Any]:
+    """Rebuild the nested dict from [(key_path, tensor), …]."""
+    root = {}
+    for path, tensor in flat:
+        cur = root
+        for k in path[:-1]:
+            cur = cur.setdefault(k, {})
+        cur[path[-1]] = tensor
+    return root
+
+
+def broadcast_nested_data_batch(nested_dict: Dict[str, Any]) -> Dict[str, Any]:
+    """Recursively broadcast nested dictionaries of tensors using each tensor's own dtype."""
+    
+    tp_group = mpu.get_tensor_model_parallel_group()
+    src      = mpu.get_tensor_model_parallel_src_rank()
+
+    # ---------- rank-0 prepares metadata ----------
+    if mpu.get_tensor_model_parallel_rank() == 0:
+        flat = flatten(nested_dict)                # [(path,tensor), …]
+        paths, tensors = zip(*flat) if flat else ([], [])
+        dtypes = [t.dtype for t in tensors]
+    else:
+        paths, dtypes = [], []
+        tensors = []
+
+    # ---------- 1. broadcast schema (paths + dtypes) ----------
+    meta = [paths, dtypes]                         # small, picklable
+    obj_list = [meta]
+    torch.distributed.broadcast_object_list(obj_list, src=src, group=tp_group)
+    paths, dtypes = obj_list[0]                    # now identical on all ranks
+
+    # ---------- 2. group tensors by dtype and broadcast ----------
+    # build maps keyed by dtype for convenience
+    dtype_to_keys = {}
+    for p, dt in zip(paths, dtypes):
+        dtype_to_keys.setdefault(dt, []).append(".".join(p))  # join for key strings
+
+    # On src rank: make a dict {joined_path: tensor}
+    if mpu.get_tensor_model_parallel_rank() == 0:
+        data_dict = {".".join(p): t.cuda() for p, t in zip(paths, tensors)}
+    else:
+        data_dict = {}
+
+    flat_out = []
+    for dt, keys in dtype_to_keys.items():
+        out = tensor_parallel.broadcast_data(keys, data_dict, dt)
+        flat_out.extend([(tuple(k.split(".")), out[k]) for k in keys])
+
+    # ---------- 3. rebuild nested structure ----------
+    return regroup(flat_out)

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/utils/logging.py

@@ -0,0 +1,50 @@
+# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+
+"""Utility functions for logging and printing MIMO model structure."""
+
+# Use Megatron utility if available – covers both distributed and non-distributed cases.
+from megatron.training.utils import print_rank_0
+
+
+def print_mimo_structure(model):
+    """Print a clean summary of MIMO model structure showing components and their types."""
+    print_rank_0("MIMO Model Structure:")
+    
+    # Print modality submodules and their components
+    print_rank_0("├── Modalities:")
+    if hasattr(model, 'modality_submodules'):
+        for modality_name, submodule in model.modality_submodules.items():
+            print_rank_0(f"│   ├── {modality_name}")
+            
+            # Print encoders
+            if hasattr(submodule, 'encoders') and submodule.encoders:
+                print_rank_0("│   │   ├── Encoders:")
+                for encoder_name, encoder in submodule.encoders.items():
+                    encoder_type = encoder.__class__.__name__
+                    print_rank_0(f"│   │   │   ├── {encoder_name}: {encoder_type}")
+            
+            # Print input projections
+            if hasattr(submodule, 'input_projections') and submodule.input_projections:
+                print_rank_0("│   │   ├── Input Projections:")
+                for i, proj in enumerate(submodule.input_projections):
+                    proj_type = proj.__class__.__name__
+                    print_rank_0(f"│   │   │   ├── {i}: {proj_type}")
+            
+            # Print decoders
+            if hasattr(submodule, 'decoders') and submodule.decoders:
+                print_rank_0("│   │   ├── Decoders:")
+                for decoder_name, decoder in submodule.decoders.items():
+                    decoder_type = decoder.__class__.__name__
+                    print_rank_0(f"│   │   │   ├── {decoder_name}: {decoder_type}")
+            
+            # Print output projections
+            if hasattr(submodule, 'output_projections') and submodule.output_projections:
+                print_rank_0("│   │   ├── Output Projections:")
+                for i, proj in enumerate(submodule.output_projections):
+                    proj_type = proj.__class__.__name__
+                    print_rank_0("│   │   │   ├── {i}: {proj_type}")
+    
+    # Print language model
+    if hasattr(model, 'language_model'):
+        lm_type = model.language_model.__class__.__name__
+        print_rank_0(f"├── Language Model: {lm_type}")

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/utils/model_helpers.py

@@ -0,0 +1,37 @@
+# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+"""
+Utility helpers for mimo models.
+"""
+
+import torch
+from megatron.core import dist_checkpointing
+
+
+def load_submodule_ckpt(module: torch.nn.Module, ckpt_dir: str):
+    """Load *ckpt_dir* into *module* using Megatron distributed-checkpointing."""
+
+    # 1) Ask for tensors using a `module.` prefix so they match checkpoint keys.
+    sharded_sd_with_prefix = module.sharded_state_dict(prefix="module.")
+
+    # Remove fp8 extra_state tensors – they may not exist in older checkpoints.
+    for k in list(sharded_sd_with_prefix.keys()):
+        if "extra_state" in k:
+            del sharded_sd_with_prefix[k]
+
+    # 2) Wrap it under a root key just as in user snippet; this becomes the state
+    #    dict returned by `load` so we can easily strip the prefix afterwards.
+    wrapper_sd = dict(state_dict=sharded_sd_with_prefix)
+    loaded = dist_checkpointing.load(
+        sharded_state_dict=wrapper_sd,
+        checkpoint_dir=ckpt_dir,
+    )
+    # 3) Remove the prefix and push into the module.
+    cleaned = {k.removeprefix("module."): v for k, v in loaded["state_dict"].items()}
+
+    incompatible = module.load_state_dict(cleaned, strict=False)
+    unexpected = [k for k in incompatible.unexpected_keys if "extra_state" not in k]
+    missing = [k for k in incompatible.missing_keys if "extra_state" not in k]
+    if unexpected or missing:
+        raise RuntimeError(
+            f"load_state_dict had unexpected mismatch. Missing: {missing}, Unexpected: {unexpected}"
+        )

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mixtral/README.md

@@ -0,0 +1,132 @@
+# Mixtral 8x7B Model Inference and Finetuning
+
+## Download Mixtral 8x7B Checkpoints
+Download Mixtral 8x7B HF format checkpoint from [HF-hub](https://huggingface.co/mistralai/Mixtral-8x7B-v0.1/)
+
+Or you can simply run this following script to download Mixtral 8x7B into a specific folder.
+```python
+from huggingface_hub import snapshot_download
+SAVED_DIR = "" # Specify the saved directory
+# Download HF checkpoints
+snapshot_download(repo_id="mistralai/Mixtral-8x7B-v0.1", ignore_patterns=["*.pt"], local_dir=SAVED_DIR, local_dir_use_symlinks=False)
+```
+
+## Convert Mixtral 8x7B checkpoints from HF to MCore
+The HF checkpoints can be converted to Megatron format by using the provided checkpoint converter for HF format.
+The target model parallel size(e.g. TP,PP,EP) should be specified.
+
+Currently the converter doesn't support distributed checkpointing yet, so each different parallel config requires a specific checkpoint.
+- For training, the recommended model parallel config is TP1EP8PP4
+- For inference, the recommended model parallel config is TP1EP1PP2
+
+```
+TOKENIZER_MODEL=/workspace/checkpoints/mixtral-hf/tokenizer.model
+MEGATRON_PATH="/workspace/megatron-lm"
+export PYTHONPATH=$MEGATRON_PATH:$PYTHONPATH
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+
+TARGET_TP_SIZE=""
+TARGET_EP_SIZE=""
+TARGET_PP_SIZE=""
+
+HF_FORMAT_DIR=/workspace/checkpoints/mixtral-hf
+MEGATRON_FORMAT_DIR=/workspace/checkpoints/mixtral-mcore-TP${TARGET_TP_SIZE}PP${TARGET_PP_SIZE}EP${TARGET_EP_SIZE}
+
+python tools/checkpoint/convert.py \
+--model-type GPT \
+--loader loader_mixtral_hf \
+--saver mcore \
+--target-tensor-parallel-size ${TARGET_TP_SIZE} \
+--target-pipeline-parallel-size ${TARGET_PP_SIZE} \
+--target-expert-parallel-size ${TARGET_EP_SIZE} \
+--load-dir ${HF_FORMAT_DIR} \
+--save-dir ${MEGATRON_FORMAT_DIR} \
+--tokenizer-model ${TOKENIZER_MODEL}
+```
+
+## Text generation with Mixtral 8x7B
+Inference with Mixtral 8x7B requires at least 2 GPUS, such that a distributed checkpoint with EP>=2 or PP>=2 converted with above script is needed.
+
+The Megatron-LM have included a simple REST server to use for text generation in `tools/run_text_generation_server.py`, launch it with the following script:
+```
+#!/bin/bash
+# This example will start serving the Mixtral 8x7B model.
+DISTRIBUTED_ARGS="--nproc_per_node 2 \
+                  --nnodes 1 \
+                  --node_rank 0 \
+                  --master_addr localhost \
+                  --master_port 6000"
+
+CHECKPOINT=<Path to checkpoint>
+TOKENIZER_MODEL=<Path to tokenizer (e.g. /tokenizer.model)>
+
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+
+pip install flask-restful
+
+torchrun $DISTRIBUTED_ARGS tools/run_text_generation_server.py   \
+       --tensor-model-parallel-size 1  \
+       --pipeline-model-parallel-size 2  \
+       --expert-model-parallel-size 1 \
+       --load ${CHECKPOINT}  \
+       --tokenizer-type Llama2Tokenizer \
+       --tokenizer-model $TOKENIZER_MODEL \
+       --use-mcore-models \
+       --max-position-embeddings 32768 \
+       --num-layers 32 \
+       --hidden-size 4096 \
+       --ffn-hidden-size 14336 \
+       --num-attention-heads 32 \
+       --normalization RMSNorm \
+       --disable-bias-linear \
+       --position-embedding-type rope \
+       --no-position-embedding \
+       --swiglu \
+       --untie-embeddings-and-output-weights \
+       --group-query-attention \
+       --num-query-groups 8 \
+       --bf16  \
+       --micro-batch-size 1  \
+       --seq-length 1024  \
+       --seed 42 \
+       --num-experts 8 \
+       --moe-router-topk 2 \
+       --moe-token-dispatcher-type alltoall \
+       --moe-grouped-gemm \
+       --mock-data \
+       --rotary-base 1000000
+```
+
+Once the server is running you can use `tools/text_generation_cli.py` to query it, it takes one argument which is the host the server is running on.
+
+```
+python tools/text_generation_cli.py localhost:5000
+```
+
+
+## Finetuning from pretrained Mixtral 8x7B
+To finetuning pretrained Mixtral 8x7B, use the following scripts:
+
+
+```bash
+PYTORCH_IMAGE=nvcr.io/nvidia/pytorch:24.04-py3
+CHECKPOINT_PATH="" # Speicfy path to checkpoint dir
+TOKENIZER_MODEL="" # Specify path to tokenizer.model
+DATA_PATH="" # Specify path to data
+
+docker run \
+    --gpus=all \
+    --ipc=host \
+    --workdir /workspace/megatron-lm \
+    -v /path/to/data:/path/to/data \
+    -v /path/to/megatron-lm:/workspace/megatron-lm \
+    $PYTORCH_IMAGE \
+    bash examples/mixtral/train_mixtral_8x7b_distributed.sh $CHECKPOINT_PATH $TOKENIZER_MODEL $DATA_PATH
+```
+
+The above functionality also applys to Mixtral 8x22B actually, you should set the model config (including hidden_size/head_num/num_layers/ffn_hidden_size) properly according to the original [config](https://huggingface.co/mistralai/Mixtral-8x22B-v0.1/blob/main/config.json).
+
+## Acknowledgements
+Contributors outside NVIDIA for the huggingface converter and example of Mixtral models in Megatron-Core:
+- Peng Li <jerry.lp@alibaba-inc.com>
+- Jun Huang <huangjun.hj@alibaba-inc.com>

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mixtral/train_mixtral_8x7b_distributed.sh

@@ -0,0 +1,116 @@
+#!/bin/bash
+
+# Runs Mixtral 8x7B model
+
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+
+GPUS_PER_NODE=8
+# Change for multinode config
+MASTER_ADDR=${MASTER_ADDR:-"localhost"}
+MASTER_PORT=${MASTER_PORT:-"6000"}
+NNODES=${SLURM_NNODES:-"1"}
+NODE_RANK=${RANK:-"0"}
+WORLD_SIZE=$(($GPUS_PER_NODE*$NNODES))
+
+CHECKPOINT_PATH=$1
+TOKENIZER_MODEL=$2
+DATA_PATH=$3
+
+DISTRIBUTED_ARGS=(
+    --nproc_per_node $GPUS_PER_NODE
+    --nnodes $NNODES
+    --node_rank $NODE_RANK
+    --master_addr $MASTER_ADDR
+    --master_port $MASTER_PORT
+)
+
+MODEL_ARGS=(
+    --use-mcore-models
+    --disable-bias-linear
+    --seq-length 4096
+    --max-position-embeddings 32768
+    --num-layers 32
+    --hidden-size 4096
+    --ffn-hidden-size 14336
+    --num-attention-heads 32
+    --init-method-std 0.01
+    --attention-dropout 0.0
+    --hidden-dropout 0.0
+    --normalization RMSNorm
+    --position-embedding-type rope
+    --swiglu
+    --untie-embeddings-and-output-weights
+    --group-query-attention
+    --num-query-groups 8
+    --no-masked-softmax-fusion
+    --no-position-embedding
+    --rotary-base 1000000
+)
+
+MOE_ARGS=(
+    --num-experts 8
+    --moe-router-topk 2
+    --moe-router-load-balancing-type aux_loss
+    --moe-aux-loss-coeff 1e-2
+    --moe-grouped-gemm
+    --moe-token-dispatcher-type alltoall
+    --overlap-param-gather
+    --overlap-grad-reduce
+)
+
+DATA_ARGS=(
+    --tokenizer-type Llama2Tokenizer
+    --tokenizer-model ${TOKENIZER_MODEL}
+    --data-path $DATA_PATH
+    --split 99990,8,2
+)
+
+TRAINING_ARGS=(
+    --micro-batch-size 1
+    --global-batch-size 256
+    --lr 1e-4
+    --train-iters 500000
+    --lr-decay-iters 320000
+    --lr-decay-style cosine
+    --min-lr 1.0e-5
+    --weight-decay 0.1
+    --lr-warmup-iters 500
+    --clip-grad 1.0
+    --bf16
+)
+
+MODEL_PARALLEL_ARGS=(
+    --tensor-model-parallel-size 1
+    --pipeline-model-parallel-size 4
+    --expert-model-parallel-size 8
+    --use-distributed-optimizer
+    --sequence-parallel
+)
+
+LOGGING_ARGS=(
+    --log-interval 1 \
+    --save-interval 10000 \
+    --eval-interval 1000 \
+    --eval-iters 10 \
+    --save $CHECKPOINT_PATH \
+    --load $CHECKPOINT_PATH \
+    --tensorboard-dir "${CHECKPOINT_PATH}/tensorboard" \
+    --no-load-optim \
+    --no-load-rng
+)
+
+if [ -n "${WANDB_API_KEY}" ]; then
+    LOGGING_ARGS+=(
+        --wandb-project ${WANDB_PROJECT:-"Mixtral"}
+        --wandb-exp-name ${WANDB_NAME:-"Mixtral_8x7B"}
+    )
+fi
+
+
+torchrun ${DISTRIBUTED_ARGS[@]} pretrain_gpt.py \
+    ${MODEL_ARGS[@]} \
+    ${MOE_ARGS[@]} \
+    ${DATA_ARGS[@]} \
+    ${TRAINING_ARGS[@]} \
+    ${MODEL_PARALLEL_ARGS[@]} \
+    ${LOGGING_ARGS[@]}

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/Dockerfile

@@ -0,0 +1,62 @@
+# Base image: NVIDIA PyTorch container with CUDA, cuDNN, NCCL, Python, and uv pre-installed
+FROM nvcr.io/nvidia/pytorch:25.12-py3
+
+# Install JRE for pycocoevalcap
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        default-jre && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+
+# Using --break-system-packages to allow system-wide installation in managed environment
+RUN uv pip install --system --no-cache --break-system-packages \
+    einops \
+    einops-exts \
+    sentencepiece \
+    braceexpand \
+    webdataset \
+    packaging \
+    "transformers<5.0.0" \
+    datasets \
+    accelerate \
+    timm \
+    pytest-cov \
+    pytest_mock \
+    nltk \
+    wrapt \
+    zarr \
+    tensorstore \
+    black \
+    isort \
+    click \
+    pycocoevalcap \
+    "megatron-energon[av_decode]~=6.0" \
+    mistral-common \
+    tiktoken \
+    # Additional dependencies for megatron-core[mlm]
+    flask-restful \
+    wandb \
+    bitstring \
+    filetype
+    setuptools
+
+# Install CLIP from GitHub
+RUN uv pip install --system --no-cache --break-system-packages --no-build-isolation \
+    git+https://github.com/openai/CLIP.git
+
+# Install packages with --no-deps to avoid outdated and unnecessary dependencies
+RUN uv pip install --system --no-cache --break-system-packages --no-deps \
+    open_clip_torch \
+    "open-flamingo[eval]"
+
+# Copy Megatron-LM source and install megatron-core
+# This assumes the build context is the Megatron-LM root directory
+# Build with: docker build -t megatron-multimodal -f examples/multimodal/Dockerfile .
+WORKDIR /workspace/megatron-lm
+COPY . .
+
+# Install megatron-core in editable mode for development
+RUN uv pip install --system --no-cache --break-system-packages --no-build-isolation -e ".[mlm]"
+
+# Set working directory to examples for convenience
+WORKDIR /workspace/megatron-lm

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/README.md

@@ -0,0 +1,161 @@
+# Multimodal Example
+
+*NOTE: This example is under active development and is expected change.*
+
+The following walks through all the steps required to pretrain and instruction tune a llava architecture vision-language model (VLM). It is important to precisely follow all steps to obtain the benchmark scores at the end.
+
+This example has been tested on an A100 based DGX cluster. Pretraining and instruction tuning took approximately 1 day and 11 hours respectively on 64 GPUs using four way tensor parallelism (tp=4). Training speed will scale approximately linearly with number of GPUs available.
+
+Multimodal support in megatron is still under active development. This example is not intended to produce state-of-the-art model quality (that would require more data and model refinements), it is merely intended to demonstrate the multimodal functionality in megatron. If you hit any problems, please open a github issue.
+
+## Setup
+
+### Docker container
+
+You can build a docker container using `examples/multimodal/Dockerfile` to run this example.
+```
+# At the Megatron-LM root directory, execute the following
+docker build -t megatron-multimodal -f examples/multimodal/Dockerfile .
+```
+
+### Language model
+
+Follow the instructions in [Mistral](../../docs/llama_mistral.md#mistral-7b) to download weights for Mistral-7B-Instruct-v0.3 from HuggingFace and convert to mcore format with tensor parallel size 4.
+Please use the tokenizer from HuggingFace.
+
+### Vision model
+
+This example uses the OpenAI CLIP `ViT-L/14@336px` Vision model. To download the weights from OpenAI and convert them to a format that can be loaded in megatron, please run the following:
+
+```
+python examples/multimodal/model_converter/clip_converter.py --download-root /some/download/folder --output /some/output/folder --tensor-parallel-size 4 --use-te
+```
+
+### Combined model checkpoint
+
+Update the paths to point to the mcore converted CLIP and Mistral models and run the following script to combine the Mistral and CLIP models into a single multimodal checkpoint folder:
+
+```
+examples/multimodal/combine_lm_vision_checkpoints.sh /path/to/mistral/model /path/to/clip/model /output/dir
+```
+
+## Training
+
+### Pretraining
+
+1. Download the LLavA-Pretrain dataset from Hugging Face and unzip the images folder (NOTE: 79GB of disk space required):
+
+    ```
+    git clone https://huggingface.co/datasets/liuhaotian/LLaVA-Pretrain
+    cd LLaVA-Pretrain
+    unzip images.zip
+    ```
+
+3. Run the following script to convert the data to webdataset format:
+
+    ```
+    cd <megatron-lm dir>
+    python examples/multimodal/convert_llava_pretrain_to_wds.py
+    ```
+
+4. Run the following command to convert to megatron-energon format:
+
+    ```
+    cd <LLaVA-Pretrain dir>/wds
+    energon prepare ./
+    ```
+
+    select the following values for the presented options:
+
+    ```
+    > Please enter a desired train/val/test split like "0.5, 0.2, 0.3" or "8,1,1": 9,1,0
+    > Do you want to create a dataset.yaml interactively? [Y/n]: Y
+    > Please enter a number to choose a class: 9 (VQASample)
+    > Do you want to set a simple field_map[Y] (or write your own sample_loader [n])? [Y/n]: Y
+    > Please enter a webdataset field name for 'image' (<class 'torch.Tensor'>): jpg
+    > Please enter a webdataset field name for 'context' (<class 'str'>): json[0][value]
+    > Please enter a webdataset field name for 'answers' (typing.Optional[typing.List[str]], default: None): json[1][value]
+    > Please enter a webdataset field name for 'answer_weights' (typing.Optional[torch.Tensor], default: None):
+    ```
+
+5. Update `pretrain_dataset.yaml` so that both `path` variables point to `LLaVA-Pretrain/wds`
+
+6. Run the following script to pretrain a llava model for image captioning:
+
+    ```
+    cd <megatron-lm dir>
+    examples/multimodal/pretrain_mistral_clip.sh
+    ```
+
+All being well you should observe training and validation loss curves similar to the following:
+
+<img src="assets/pretrain_curves.png" alt="Pretraining loss curves" width="600"/>
+
+These curves were obtained with global batch size of 256. Changing this value will likely change the curves. For pretraining and instruction tuning llava models we have found that loss curves are an unreliable predictor of downstream task performance. Therefore it is necessary to run test generation and evaluation on a range of metrics to understand model quality. We intend to add training time zero-shot evaluation in a future update.
+
+You can execute the pretraining script multiple times to resume training. On resuming, the latest model, optimizer, and dataloader state are loaded.
+
+### SFT
+
+1. Prepare an instruction tuning dataset such in [megatron-energon format](https://nvidia.github.io/Megatron-Energon/data_prep.html#). NOTE: we do not provide instructions for this.
+
+2. Update `sft_dataset.yaml` so that both `path` variables point to the train and val splits of your instruction tuning dataset.
+
+Run the following script to instruction tune the pre-trained llava model:
+
+    ```
+    examples/multimodal/sft_mistral_clip.sh
+    ```
+
+You can execute the SFT script multiple times to resume training. On resuming, the latest model, optimizer, and dataloader state are loaded.
+
+## Evaluation
+
+### Generation
+
+Run the following script:
+
+```
+examples/multimodal/text_generation_mistral_clip.sh --input-image-path /path/to/input/images --output-path /some/output/directory \
+    --model-path /path/to/model.pt --gt-path /path/to/groundtruth/file --task generation-task-name
+```
+
+where `--task generation-task-name` is the name of the evaluation benchmark such as `captioning` or `MMMU`.
+
+### After pretraining
+
+#### COCO captioning
+
+1. Download the COCO 2014 test image set:
+
+    ```wget http://images.cocodataset.org/zips/test2014.zip```
+
+2. Download COCO test image annotations:
+
+    ```https://storage.googleapis.com/sfr-vision-language-research/datasets/coco_karpathy_test.json```
+
+3. First, run text generation using `--task captioning`.
+
+4. Run the following command:
+
+    ```
+    python examples/multimodal/evaluate_coco.py --input-path /output/directory/from/generation --groundtruth-path /path/to/groundtruth/file
+    ```
+
+For the mistral-7b-instruct plus clip llava model you should obtain a COCO CIDer score of approximately 94.
+
+### After SFT
+
+#### MMMU
+
+The official MMMU repository is not pip installable currently so please clone their code in `examples/multimodal` by running `git clone https://github.com/MMMU-Benchmark/MMMU.git`.
+
+The MMMU dataset is loaded from HuggingFace automatically as part of the code.
+
+Run text generation using `--task MMMU`. Then, run the following command:
+
+```
+python examples/multimodal/evaluate_mmmu.py --input-path /output/directory/from/generation
+```
+
+For the mistral-7b-instruct plus clip instruction tuned llava model you should obtain a MMMU score of approximately 38.

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/combine_lm_vision_checkpoints.sh

@@ -0,0 +1,57 @@
+#/bin/bash
+MCORE_LM=$1    # <path_to_mcore_lm_model_folder>
+MCORE_VISION=$2   # <path_to_mcore_vision_model_folder>
+OUTPUT_DIR=$3   # <path_to_output_folder_for_combined_checkpoint>
+MODEL_TYPE=$4   # Model type. Default: Mistral CLIP example.
+
+if [[ $MODEL_TYPE == "nvlm" ]]; then
+    # NVLM TP=8
+    python examples/multimodal/combine_state_dicts.py \
+        --input \
+        ${MCORE_LM}/iter_0000001/mp_rank_00/model_optim_rng.pt \
+        ${MCORE_VISION}/iter_0000001/mp_rank_00/model_optim_rng.pt \
+        ${MCORE_LM}/iter_0000001/mp_rank_01/model_optim_rng.pt \
+        ${MCORE_VISION}/iter_0000001/mp_rank_01/model_optim_rng.pt \
+        ${MCORE_LM}/iter_0000001/mp_rank_02/model_optim_rng.pt \
+        ${MCORE_VISION}/iter_0000001/mp_rank_02/model_optim_rng.pt \
+        ${MCORE_LM}/iter_0000001/mp_rank_03/model_optim_rng.pt \
+        ${MCORE_VISION}/iter_0000001/mp_rank_03/model_optim_rng.pt \
+        ${MCORE_LM}/iter_0000001/mp_rank_04/model_optim_rng.pt \
+        ${MCORE_VISION}/iter_0000001/mp_rank_04/model_optim_rng.pt \
+        ${MCORE_LM}/iter_0000001/mp_rank_05/model_optim_rng.pt \
+        ${MCORE_VISION}/iter_0000001/mp_rank_05/model_optim_rng.pt \
+        ${MCORE_LM}/iter_0000001/mp_rank_06/model_optim_rng.pt \
+        ${MCORE_VISION}/iter_0000001/mp_rank_06/model_optim_rng.pt \
+        ${MCORE_LM}/iter_0000001/mp_rank_07/model_optim_rng.pt \
+        ${MCORE_VISION}/iter_0000001/mp_rank_07/model_optim_rng.pt \
+        --prefixes language_model vision_model language_model vision_model language_model vision_model language_model vision_model language_model vision_model language_model vision_model language_model vision_model language_model vision_model \
+        --output \
+        ${OUTPUT_DIR}/iter_0000001/mp_rank_00/model_optim_rng.pt \
+        ${OUTPUT_DIR}/iter_0000001/mp_rank_01/model_optim_rng.pt \
+        ${OUTPUT_DIR}/iter_0000001/mp_rank_02/model_optim_rng.pt \
+        ${OUTPUT_DIR}/iter_0000001/mp_rank_03/model_optim_rng.pt \
+        ${OUTPUT_DIR}/iter_0000001/mp_rank_04/model_optim_rng.pt \
+        ${OUTPUT_DIR}/iter_0000001/mp_rank_05/model_optim_rng.pt \
+        ${OUTPUT_DIR}/iter_0000001/mp_rank_06/model_optim_rng.pt \
+        ${OUTPUT_DIR}/iter_0000001/mp_rank_07/model_optim_rng.pt
+else
+    # Mistral CLIP example TP=4.
+    python examples/multimodal/combine_state_dicts.py \
+        --input \
+        ${MCORE_LM}/iter_0000001/mp_rank_00/model_optim_rng.pt \
+        ${MCORE_VISION}/iter_0000001/mp_rank_00/model_optim_rng.pt \
+        ${MCORE_LM}/iter_0000001/mp_rank_01/model_optim_rng.pt \
+        ${MCORE_VISION}/iter_0000001/mp_rank_01/model_optim_rng.pt \
+        ${MCORE_LM}/iter_0000001/mp_rank_02/model_optim_rng.pt \
+        ${MCORE_VISION}/iter_0000001/mp_rank_02/model_optim_rng.pt \
+        ${MCORE_LM}/iter_0000001/mp_rank_03/model_optim_rng.pt \
+        ${MCORE_VISION}/iter_0000001/mp_rank_03/model_optim_rng.pt \
+        --prefixes language_model vision_model language_model vision_model language_model vision_model language_model vision_model \
+        --output \
+        ${OUTPUT_DIR}/iter_0000001/mp_rank_00/model_optim_rng.pt \
+        ${OUTPUT_DIR}/iter_0000001/mp_rank_01/model_optim_rng.pt \
+        ${OUTPUT_DIR}/iter_0000001/mp_rank_02/model_optim_rng.pt \
+        ${OUTPUT_DIR}/iter_0000001/mp_rank_03/model_optim_rng.pt
+fi
+
+echo 1 > ${OUTPUT_DIR}/latest_checkpointed_iteration.txt

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/combine_state_dicts.py

@@ -0,0 +1,81 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+
+import argparse
+import os
+import sys
+
+import torch
+
+# Add megatron to the path.
+sys.path.append(
+    os.path.abspath(os.path.join(os.path.dirname(__file__), os.path.pardir, os.path.pardir))
+)
+
+
+def combine(input_files, module_prefixes, output_files):
+    num_inputs_per_output = int(len(input_files) / len(output_files))
+
+    for output_idx, output_file in enumerate(output_files):
+        combined_state_dict = None
+
+        lb = output_idx * num_inputs_per_output
+        ub = (output_idx + 1) * num_inputs_per_output
+        current_input_files = input_files[lb:ub]
+        current_module_prefixes = module_prefixes[lb:ub]
+
+        for i, (input_file, module_prefix) in enumerate(
+            zip(current_input_files, current_module_prefixes)
+        ):
+            # initialize the combined state dict using the first provided input file
+            current_state_dict = torch.load(input_file, weights_only=False)
+            if i == 0:
+                combined_state_dict = current_state_dict.copy()
+                combined_state_dict["model"] = dict()
+
+            # copy model state dict and prefix names with the given module keys.
+            for k, v in current_state_dict["model"].items():
+                combined_state_dict["model"]["%s.%s" % (module_prefix, k)] = v
+
+        output_dir = os.path.dirname(output_file)
+        if not os.path.exists(output_dir):
+            os.makedirs(output_dir, exist_ok=True)
+        torch.save(combined_state_dict, output_file)
+        print("saved:", output_file)
+
+    print("done.")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="""
+        Combine multiple state dicts into a single state dict.
+        The combined state dict is first initialized by taking a copy of the first provided input state dict.
+        To avoid conflicts in model parameter names, a prefix must be provided for each input file.
+        Model parameter names will be renamed from <original name> to <model prefix>.<original name>.
+
+
+        Example usage:
+        python combine_state_dicts.py --input language_model.pt vision_model.pt --prefixes language_model vision_model --output multimodal.pt
+        """,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("--input", nargs="*", required=True, help="paths to input state dict files")
+    parser.add_argument(
+        "--prefixes",
+        nargs="*",
+        required=True,
+        help="prefixes to use with each input model's parameters",
+    )
+    parser.add_argument(
+        "--output", nargs="*", required=True, help="path(s) to output state dict file"
+    )
+
+    args = parser.parse_args()
+
+    assert len(args.input) > 1, "must provide more than 1 input model to combine"
+    assert len(args.input) == len(args.prefixes), "each input model must have a corresponding key"
+    assert (
+        len(args.input) % len(args.output) == 0
+    ), "each output file must use the same number of input files"
+
+    combine(args.input, args.prefixes, args.output)

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/config.py

@@ -0,0 +1,412 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+from dataclasses import dataclass
+
+import torch
+
+from megatron.core.activations import fast_gelu, quick_gelu, squared_relu
+
+
+def get_language_model_config(config):
+    if config.language_model_type == "llama3_8b":
+        config.activation_func = torch.nn.functional.silu
+        config.add_bias_linear = False
+        config.bias_activation_fusion = False
+        config.gated_linear_unit = True
+        config.apply_query_key_layer_scaling = False
+        config.layernorm_zero_centered_gamma = (
+            False  # Zero centered gamma not supported for RMSNorm
+        )
+        config.bias_dropout_fusion = False
+        config.apply_rope_fusion = False
+        config.attention_softmax_in_fp32 = True
+        config.ffn_hidden_size = 14336
+    elif config.language_model_type == "llama3.1_8b":
+        config.activation_func = torch.nn.functional.silu
+        config.add_bias_linear = False
+        config.bias_activation_fusion = False
+        config.gated_linear_unit = True
+        config.apply_query_key_layer_scaling = False
+        config.layernorm_zero_centered_gamma = (
+            False  # Zero centered gamma not supported for RMSNorm
+        )
+        config.bias_dropout_fusion = False
+        config.apply_rope_fusion = False
+        config.attention_softmax_in_fp32 = True
+        config.ffn_hidden_size = 14336
+    elif config.language_model_type == "llama3.1_70B":
+        config.activation_func = torch.nn.functional.silu
+        config.add_bias_linear = False
+        config.bias_activation_fusion = False
+        config.gated_linear_unit = True
+        config.apply_query_key_layer_scaling = False
+        config.layernorm_zero_centered_gamma = (
+            False  # Zero centered gamma not supported for RMSNorm
+        )
+        config.bias_dropout_fusion = False
+        config.apply_rope_fusion = False
+        config.attention_softmax_in_fp32 = True
+        config.ffn_hidden_size = 28672
+    elif config.language_model_type == "mistral_7b":
+        config.activation_func = torch.nn.functional.silu
+        config.add_bias_linear = False
+        config.bias_activation_fusion = False
+        config.gated_linear_unit = True
+        config.apply_query_key_layer_scaling = False
+        config.layernorm_zero_centered_gamma = (
+            False  # Zero centered gamma not supported for RMSNorm
+        )
+        config.bias_dropout_fusion = False
+        config.apply_rope_fusion = False
+        config.attention_softmax_in_fp32 = True
+        config.ffn_hidden_size = 14336
+    elif config.language_model_type == "nemotron5-8b":
+        config.add_bias_linear = False
+        config.bias_activation_fusion = False
+        config.gated_linear_unit = False
+        config.bias_dropout_fusion = False
+        config.apply_rope_fusion = False
+        config.activation_func = squared_relu
+        config.ffn_hidden_size = 21504
+        config.masked_softmax_fusion = True
+        config.attention_softmax_in_fp32 = True
+    elif config.language_model_type == "yi-34b":
+        config.activation_func = torch.nn.functional.silu
+        config.add_bias_linear = False
+        config.bias_activation_fusion = False
+        config.gated_linear_unit = True
+        config.apply_query_key_layer_scaling = False
+        config.layernorm_zero_centered_gamma = (
+            False  # Zero centered gamma not supported for RMSNorm
+        )
+        config.bias_dropout_fusion = False
+        config.apply_rope_fusion = False
+        config.attention_softmax_in_fp32 = True
+        config.ffn_hidden_size = 20480
+    elif config.language_model_type == "qwen2.0_72B":
+        config.activation_func = torch.nn.functional.silu
+        config.add_bias_linear = False
+        config.add_qkv_bias = True
+        config.bias_activation_fusion = False
+        config.gated_linear_unit = True
+        config.apply_query_key_layer_scaling = False
+        config.layernorm_zero_centered_gamma = (
+            False  # Zero centered gamma not supported for RMSNorm
+        )
+        config.bias_dropout_fusion = False
+        config.apply_rope_fusion = False
+        config.attention_softmax_in_fp32 = True
+        config.ffn_hidden_size = 29568
+    elif config.language_model_type == "qwen2.5_7B":
+        config.activation_func = torch.nn.functional.silu
+        config.add_bias_linear = False
+        config.add_qkv_bias = True
+        config.bias_activation_fusion = False
+        config.gated_linear_unit = True
+        config.apply_query_key_layer_scaling = False
+        config.layernorm_zero_centered_gamma = (
+            False  # Zero centered gamma not supported for RMSNorm
+        )
+        config.bias_dropout_fusion = False
+        config.apply_rope_fusion = False
+        config.attention_softmax_in_fp32 = True
+        config.ffn_hidden_size = 18944
+    elif config.language_model_type == "qwen2.5_72B":
+        config.activation_func = torch.nn.functional.silu
+        config.add_bias_linear = False
+        config.add_qkv_bias = True
+        config.bias_activation_fusion = False
+        config.gated_linear_unit = True
+        config.apply_query_key_layer_scaling = False
+        config.layernorm_zero_centered_gamma = (
+            False  # Zero centered gamma not supported for RMSNorm
+        )
+        config.bias_dropout_fusion = False
+        config.apply_rope_fusion = False
+        config.attention_softmax_in_fp32 = True
+        config.ffn_hidden_size = 29568
+    elif config.language_model_type == "nemotron5-hybrid-8b":
+        config.activation_func = squared_relu
+        config.squared_relu = True
+        config.add_bias_linear = False
+        config.bias_activation_fusion = False
+        config.apply_query_key_layer_scaling = False
+        config.gated_linear_unit = False
+        config.layernorm_zero_centered_gamma = (
+            False  # Zero centered gamma not supported for RMSNorm
+        )
+        config.bias_dropout_fusion = False
+        config.attention_softmax_in_fp32 = True
+        config.ffn_hidden_size = 21504
+    elif config.language_model_type == "nemotron5-hybrid-56b":
+        config.activation_func = squared_relu
+        config.squared_relu = True
+        config.add_bias_linear = False
+        config.bias_activation_fusion = False
+        config.apply_query_key_layer_scaling = False
+        config.gated_linear_unit = False
+        config.layernorm_zero_centered_gamma = (
+            False  # Zero centered gamma not supported for RMSNorm
+        )
+        config.bias_dropout_fusion = False
+        config.attention_softmax_in_fp32 = True
+        config.ffn_hidden_size = 32768
+        config.mamba_state_dim = 256
+    elif config.language_model_type == "llama3.2_1b":
+        config.activation_func = torch.nn.functional.silu
+        config.add_bias_linear = False
+        config.bias_activation_fusion = False
+        config.gated_linear_unit = True
+        config.apply_query_key_layer_scaling = False
+        config.layernorm_zero_centered_gamma = (
+            False  # Zero centered gamma not supported for RMSNorm
+        )
+        config.bias_dropout_fusion = False
+        config.apply_rope_fusion = False
+        config.attention_softmax_in_fp32 = True
+        config.ffn_hidden_size = 8192
+    elif config.language_model_type.startswith("hf://"):
+        # Loaded from HuggingFace config file.
+        import transformers
+        hf_config = transformers.AutoConfig.from_pretrained(config.language_model_type.split("hf://")[1])
+        config.hf_config = hf_config
+        config.hidden_size = hf_config.hidden_size
+    else:
+        raise ValueError(f"unknown language model type {config.language_model_type}")
+
+    return config
+
+
+def get_vision_model_config(config, apply_query_key_layer_scaling):
+    if config.vision_model_type == "clip":
+        config.num_layers = 24
+        config.num_attention_heads = 16
+        config.add_bias_linear = True
+        config.add_qkv_bias = True
+        config.hidden_size = 1024
+        config.hidden_dropout = 0.0
+        config.attention_dropout = 0.0
+        config.ffn_hidden_size = 4096
+        config.gated_linear_unit = False
+        config.activation_func = quick_gelu
+        config.kv_channels = 64
+        config.num_query_groups = 16
+        config.layernorm_zero_centered_gamma = False
+        config.apply_query_key_layer_scaling = apply_query_key_layer_scaling
+        config.bias_activation_fusion = False
+        config.bias_dropout_fusion = False
+        config.attention_softmax_in_fp32 = True
+        config.normalization = 'LayerNorm'
+        config.apply_rope_fusion = False
+    elif config.vision_model_type == "siglip":
+        config.num_layers = 27
+        config.num_attention_heads = 16
+        config.add_bias_linear = True
+        config.add_qkv_bias = True
+        config.hidden_size = 1152
+        config.hidden_dropout = 0.0
+        config.attention_dropout = 0.0
+        config.ffn_hidden_size = 4304
+        config.gated_linear_unit = False
+        config.activation_func = fast_gelu
+        config.kv_channels = 72
+        config.num_query_groups = 16
+        config.layernorm_zero_centered_gamma = False
+        config.apply_query_key_layer_scaling = apply_query_key_layer_scaling
+        config.bias_activation_fusion = False
+        config.bias_dropout_fusion = False
+        config.attention_softmax_in_fp32 = True
+        config.normalization = 'LayerNorm'
+        config.apply_rope_fusion = False
+        config.qk_layernorm = False
+        config.layernorm_epsilon = 1e-6
+    elif config.vision_model_type == "internvit":
+        config.num_layers = 45
+        config.num_attention_heads = ((24 // config.tensor_model_parallel_size) + 1) * config.tensor_model_parallel_size
+        config.num_query_groups = config.num_attention_heads
+        config.add_bias_linear = True
+        config.add_qkv_bias = False
+        config.hidden_size = 3200
+        config.hidden_dropout = 0.0
+        config.attention_dropout = 0.0
+        config.ffn_hidden_size = 12800
+        config.gated_linear_unit = False
+        config.activation_func = torch.nn.functional.gelu
+        config.layernorm_zero_centered_gamma = False
+        config.apply_query_key_layer_scaling = apply_query_key_layer_scaling
+        config.bias_activation_fusion = False
+        config.bias_dropout_fusion = False
+        config.attention_softmax_in_fp32 = True
+        config.normalization = 'RMSNorm'
+        config.layernorm_epsilon = 1e-6
+        config.apply_rope_fusion = False
+    elif config.vision_model_type == "internvit300M":
+        config.num_layers = 24
+        config.num_attention_heads = 16
+        config.num_query_groups = config.num_attention_heads
+        config.add_bias_linear = True
+        config.add_qkv_bias = True
+        config.hidden_size = 1024
+        config.kv_channels = 64
+        config.hidden_dropout = 0.0
+        config.ffn_hidden_size = 4096
+        config.gated_linear_unit = False
+        config.activation_func = torch.nn.functional.gelu
+        config.layernorm_zero_centered_gamma = False
+        config.apply_query_key_layer_scaling = apply_query_key_layer_scaling
+        config.bias_activation_fusion = False
+        config.bias_dropout_fusion = False
+        config.attention_softmax_in_fp32 = True
+        config.normalization = 'LayerNorm'
+        config.layernorm_epsilon = 1e-6
+        config.apply_rope_fusion = False
+        config.qk_layernorm = False
+    elif config.vision_model_type == "radio":
+        config.num_layers = 32
+        config.num_attention_heads = 16
+        config.add_bias_linear = True
+        config.add_qkv_bias = True
+        config.hidden_size = 1280
+        config.ffn_hidden_size = 5120
+        config.gated_linear_unit = False
+        config.activation_func = fast_gelu
+        config.kv_channels = 80
+        config.num_query_groups = 16
+        config.layernorm_zero_centered_gamma = False
+        config.apply_query_key_layer_scaling = apply_query_key_layer_scaling
+        config.bias_activation_fusion = False
+        config.bias_dropout_fusion = False
+        config.attention_softmax_in_fp32 = True
+        config.normalization = 'LayerNorm'
+        config.apply_rope_fusion = False
+        config.qk_layernorm = False
+        config.layernorm_epsilon = 1e-6
+    elif config.vision_model_type == "radio-g":
+        config.num_layers = 40
+        config.num_attention_heads = 24
+        config.add_bias_linear = True
+        config.add_qkv_bias = True
+        config.hidden_size = 1536
+        config.ffn_hidden_size = 4096
+        config.gated_linear_unit = True
+        config.activation_func = torch.nn.functional.silu
+        config.kv_channels = 64
+        config.num_query_groups = 24
+        config.layernorm_zero_centered_gamma = False
+        config.apply_query_key_layer_scaling = apply_query_key_layer_scaling
+        config.bias_activation_fusion = False
+        config.bias_dropout_fusion = False
+        config.attention_softmax_in_fp32 = True
+        config.normalization = 'LayerNorm'
+        config.apply_rope_fusion = False
+        config.qk_layernorm = False
+        config.layernorm_epsilon = 1e-6
+    elif config.vision_model_type == "cradio-g":
+        config.num_layers = 40
+        config.num_attention_heads = 24
+        config.add_bias_linear = True
+        config.add_qkv_bias = True
+        config.hidden_size = 1536
+        config.ffn_hidden_size = 6144
+        config.gated_linear_unit = False
+        config.activation_func = fast_gelu
+        config.kv_channels = 64
+        config.num_query_groups = 24
+        config.layernorm_zero_centered_gamma = False
+        config.apply_query_key_layer_scaling = apply_query_key_layer_scaling
+        config.bias_activation_fusion = False
+        config.bias_dropout_fusion = False
+        config.attention_softmax_in_fp32 = True
+        config.normalization = 'LayerNorm'
+        config.apply_rope_fusion = False
+        config.qk_layernorm = False
+        config.layernorm_epsilon = 1e-6
+    elif config.vision_model_type.startswith("hf://"):
+        import transformers
+        hf_config = transformers.AutoConfig.from_pretrained(config.vision_model_type.split("hf://")[1])
+        config.hf_config = hf_config
+        config.hidden_size = hf_config.hidden_size
+    else:
+        raise ValueError(f"unknown vision model type {config.vision_model_type}")
+
+    return config
+
+
+def get_vision_projection_config(config, hidden_size):
+    # If using FP8, then keep the whole vision projection in FP8.
+    config.first_last_layers_bf16 = False
+    config.num_layers_at_start_in_bf16 = 0
+    config.num_layers_at_end_in_bf16 = 0
+
+    config.gated_linear_unit = False
+    config.bias_activation_fusion = False
+    config.add_bias_linear = False
+    config.hidden_size = hidden_size  # Used as the vision projection output size, i.e., the input to the language model.
+    if config.language_model_type == "llama3_8b":
+        config.ffn_hidden_size = 14336
+        config.activation_func = torch.nn.functional.gelu
+    elif config.language_model_type == "llama3.1_8b":
+        config.ffn_hidden_size = 4096
+        config.activation_func = torch.nn.functional.gelu
+        config.layernorm_epsilon = 1e-5
+        config.add_bias_linear = True
+        config.normalization = "LayerNorm"
+    elif config.language_model_type == "mistral_7b":
+        config.ffn_hidden_size = 14336
+        config.activation_func = torch.nn.functional.gelu
+        config.normalization = None
+    elif config.language_model_type == "yi-34b":
+        config.ffn_hidden_size = 20480
+        config.normalization = "LayerNorm"
+        config.activation_func = torch.nn.functional.gelu
+    elif config.language_model_type == "qwen2.0_72B":
+        config.ffn_hidden_size = 29568
+        config.normalization = "LayerNorm"
+        config.activation_func = torch.nn.functional.gelu
+    elif config.language_model_type == "qwen2.5_7B":
+        config.ffn_hidden_size = 3584
+        config.activation_func = torch.nn.functional.gelu
+    elif config.language_model_type == "qwen2.5_72B":
+        config.ffn_hidden_size = 29568
+        config.normalization = "LayerNorm"
+        config.activation_func = torch.nn.functional.gelu
+    elif config.language_model_type == "nemotron5-hybrid-56b":
+        config.ffn_hidden_size = 32768
+        config.activation_func = squared_relu
+    elif config.language_model_type in ("nemotron5-8b", "nemotron5-hybrid-8b"):
+        config.ffn_hidden_size = 21504
+        config.activation_func = squared_relu
+    elif config.language_model_type == "llama3.2_1b":
+        config.ffn_hidden_size = 2048
+        config.activation_func = torch.nn.functional.gelu
+        config.normalization = "LayerNorm"
+    elif config.language_model_type.startswith("hf://"):
+        config.activation_func = torch.nn.functional.gelu
+        config.ffn_hidden_size = 4096
+        config.normalization = "LayerNorm"
+    else:
+        raise ValueError(f"unknown language model type {config.language_model_type}")
+
+    return config
+
+
+@dataclass
+class EvaluationConfig:
+    """Evaluation related configuration."""
+    task: str
+    dataset: str = ""
+
+    temperature: float = 1.0
+    top_p: float = 0.0
+    top_k: int = 0
+
+    out_seq_length: int = 32
+
+    output_path: str = ""
+
+    input_image_path: str = ""
+    gt_path: str = ""
+    split: str = "validation"
+
+    num_partitions: int = 0
+    partition_id: int = 0
+    num_samples_per_partition: int = 0

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/convert_llava_pretrain_to_wds.py

@@ -0,0 +1,31 @@
+import json
+import os
+import webdataset as wds
+
+from tqdm import tqdm
+
+llava_pretrain_dir = '<path_to_LLaVA-Pretrain>'
+
+# Paths to the dataset files
+json_file = os.path.join(llava_pretrain_dir, 'blip_laion_cc_sbu_558k.json')
+output = os.path.join(llava_pretrain_dir, 'wds')
+
+if not os.path.exists(output):
+    os.mkdir(output)
+
+# Load data
+with open(json_file, 'r') as f:
+    data = json.load(f)
+
+with wds.ShardWriter(os.path.join(output, 'pretrain-%d.tar'), maxcount=10000) as shard_writer:
+    for entry in tqdm(data):
+        with open(os.path.join(llava_pretrain_dir, entry['image']), "rb") as img_file:
+                image_data = img_file.read()
+        sample = {
+            "__key__": entry['id'],
+            "jpg": image_data,
+            "json": json.dumps(entry['conversations']).encode("utf-8"),
+        }
+        shard_writer.write(sample)
+
+print(f"Dataset successfully converted to wds")

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/dataloader_provider.py

@@ -0,0 +1,171 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+import os
+
+import torch
+from dataset_helpers import TaskEncoder, print_error_handler
+
+from megatron.core import parallel_state
+from megatron.core.num_microbatches_calculator import get_num_microbatches
+from megatron.core.parallel_state import (
+    get_pipeline_model_parallel_rank,
+    get_pipeline_model_parallel_world_size,
+    get_tensor_model_parallel_rank,
+)
+from megatron.energon import (
+    LimitDataset,
+    RepeatDataset,
+    WorkerConfig,
+    get_loader,
+    get_savable_loader,
+    get_train_dataset,
+    get_val_datasets,
+)
+from megatron.training import get_args
+from megatron.training.checkpointing import get_checkpoint_name
+
+
+def datasets_provider(task_encoder,worker_config=None):
+    """Create multimodal train, validation and test datasets."""
+    args = get_args()
+
+    dname = args.data_path[0] if type(args.data_path) is list else args.data_path
+    train_dataset = get_train_dataset(
+        dname,
+        batch_size=args.micro_batch_size,
+        task_encoder=task_encoder,
+        virtual_epoch_length=1000,
+        max_samples_per_sequence=100,
+        shuffle_buffer_size=100,
+        worker_config=worker_config,
+        packing_buffer_size=args.packing_buffer_size,
+        handler=print_error_handler,
+        image_decode="pil",
+    )
+
+    val_datasets = get_val_datasets(
+        dname,
+        batch_size=args.micro_batch_size,
+        # This is the total number over all workers
+        # limit=args.eval_iters * get_num_microbatches(),
+        task_encoder=task_encoder,
+        worker_config=worker_config,
+        packing_buffer_size=args.packing_buffer_size,
+        handler=print_error_handler,
+        image_decode="pil",
+    )
+    val_datasets_without_source_datasets = [
+        # Limit the dataset to eval_iters * num_microbatches
+        LimitDataset(
+            # Repeat the inner dataset in case it's too short
+            RepeatDataset(val_ds, worker_config=worker_config),
+            length=args.eval_iters * get_num_microbatches(),
+            worker_config=worker_config,
+            reset_after_epoch=True,
+        )
+        for val_ds, _src_ds in val_datasets
+    ]
+
+    return train_dataset, val_datasets_without_source_datasets, None
+
+
+def is_first_or_last_stage(pp_size):
+    """Check if the current pipeline parallel stage is the first or last stage."""
+    if pp_size == 1:    # No pipeline parallelism.
+        return True
+
+    # With no separate pipeline stage for the vision model (epp=0), 
+    # run the dataloader on the first and last pipeline stage.
+    pp_rank = get_pipeline_model_parallel_rank()
+    is_valid_rank = pp_rank in (0, pp_size-1)
+
+    return is_valid_rank
+
+
+def is_dataloader_rank():
+    """Check if we should have the dataloader on this tensor and pipeline parallel rank."""
+    # Run dataloader only on the first tensor parallel rank (will be broadcasted to others).
+    is_first_rank = get_tensor_model_parallel_rank() == 0
+
+    pp_size = get_pipeline_model_parallel_world_size()
+    is_first_rank = is_first_rank and is_first_or_last_stage(pp_size)
+
+    return is_first_rank
+
+
+def train_valid_test_dataloaders_provider(train_val_test_num_samples, task_encoder=None):
+    """Build multimodal train, validation and test dataloaders."""
+    args = get_args()
+    
+    if task_encoder is None:
+        task_encoder = TaskEncoder()
+
+    # Dataloader is only on specific ranks.
+    if not is_dataloader_rank():
+        return None, None, None
+
+    worker_debug_path = None
+    worker_log_level = 0
+
+    rank = parallel_state.get_data_parallel_rank()
+    world_size = parallel_state.get_data_parallel_world_size()
+    data_parallel_group = parallel_state.get_data_parallel_group()
+
+    worker_config = WorkerConfig(
+        rank=rank,
+        world_size=world_size,
+        num_workers=args.num_workers,
+        data_parallel_group=data_parallel_group,
+        worker_debug_path=worker_debug_path,
+        worker_log_level=worker_log_level,
+    )
+    train_ds, valid_ds1, test_ds = datasets_provider(task_encoder, worker_config)
+
+    train_dataloader = get_savable_loader(train_ds, worker_config=worker_config)
+    if args.load is not None:
+        if getattr(args, "dataloader_save", None):
+            dp_rank = parallel_state.get_data_parallel_rank()
+            data_save_name = get_checkpoint_name(
+                args.dataloader_save,
+                args.iteration,
+                pipeline_rank=0,    # Only the first pipeline parallel rank stores the dataloader checkpoint.
+                basename=f"train_dataloader_dprank{dp_rank:03d}.pt",
+            )
+            if os.path.exists(data_save_name):
+                try:
+                    dataset_state_dict = torch.load(data_save_name, map_location="cpu")
+                    train_dataloader.restore_state_rank(dataset_state_dict["dataloader_state_dict"])
+                    print(f"restored dataset state from {data_save_name}")
+                except Exception as e:
+                    print("loading dataset state failed. Skipping. " + str(e))
+            else:
+                print(f"dataset state {data_save_name} does not exist")
+
+    valid_dataloader = [
+        EnergonDataloader(get_loader(valid_ds, worker_config=worker_config))
+        for valid_ds in valid_ds1
+    ]
+    test_dataloader = None
+
+    return EnergonDataloader(train_dataloader), valid_dataloader, EnergonDataloader(test_dataloader)
+
+
+class EnergonDataloader:
+    """A wrapper to use Megatron Energon dataloader with the Megatron-LM training loop."""
+    def __init__(self, dataloader):
+        self._dataloader = dataloader
+        self._iter = iter(cyclic_iter(dataloader))
+
+    def __next__(self):
+        return self._iter.__next__()
+
+    def __iter__(self):
+        return self._iter.__iter__()
+
+    def save_state(self):
+        return self._dataloader.save_state_rank()
+
+
+def cyclic_iter(iter):
+    while True:
+        for x in iter:
+            yield x

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/dataset_helpers.py

@@ -0,0 +1,966 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+import bisect
+import dataclasses
+import json
+import re
+import sys
+import traceback
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Tuple, Union
+
+from image_processing import ImageTransform, find_closest_aspect_ratio, find_closest_area_weighted_aspect_ratio
+from PIL import Image
+from torchvision.transforms import ToPILImage
+import numpy as np
+import torch
+
+from energon_util import OfflineTargetAspectRatioSample, SampleListSample
+from megatron.core.models.multimodal.context_parallel import get_padding
+from megatron.core.models.multimodal.llava_model import IGNORE_INDEX, IMAGE_TOKEN, VIDEO_TOKEN
+from megatron.core.models.vision.clip_vit_model import get_num_image_embeddings
+from megatron.energon import (
+    Batch,
+    CaptioningSample,
+    DefaultTaskEncoder,
+    OCRSample,
+    Sample,
+    SimilarityInterleavedSample,
+    VQASample,
+    MultiChoiceVQASample
+)
+from megatron.energon.task_encoder.base import stateless
+from megatron.training import get_args, get_tokenizer
+
+
+@dataclass
+class ImageTaskSample(Sample):
+    __key__: str
+    __restore_key__: Tuple[Union[str, int, tuple], ...]
+    __subflavor__: Dict
+    __subflavors__: Dict
+    # (c, h, w)
+    imgs: List[torch.Tensor]
+    num_tiles: List[int]
+    tokens: torch.Tensor
+    total_len: int  # Total token count in the sample, including text and image tokens
+    labels: torch.Tensor = None
+
+
+@dataclass
+class ImageTaskSamplePacked(Sample):
+    """Dataclass to store a single packed sample (not a batch).
+
+        P = Number of sub-samples in the packed sample
+        seq_len = Total sequence length
+        num_imgs = Number of images across all samples in the packed sample
+    """
+
+    __key__: str    # Sample name
+    __restore_key__: Tuple[Union[str, int, tuple], ...]
+    __subflavor__: Dict     # Sample metadata. Deprecated.
+    __subflavors__: Dict    # Sample metadata.
+    tokens: torch.Tensor  # Input tokens packed into a single tensor (seq_len,)
+    labels: torch.Tensor # Target tokens packed into a single tensor (seq_len,)
+    imgs: List[torch.Tensor]    # Input images
+    num_tiles: List[int]  # Number of tiles for each image of each sample (num_imgs)
+    max_length: int    # Maximum length across sub-samples.
+    cu_lengths: List[int]  # Cumulative length of each sub-sample in this packed sample incl. text and image tokens (P,)
+
+
+# Typing for the resulting batch data after encode_batch()
+@dataclass
+class ImageTaskBatchPacked(Batch):
+    """Dataclass to store a batch of packed samples.
+
+        N = Batch size
+        P = Number of samples in the packed sample
+        seq_len = Maximum sequence length
+        num_imgs = Number of images across all samples in the packed sample
+    """
+
+    __key__: List[str]  # Sample names
+    __restore_key__: Tuple[Union[str, int, tuple], ...]
+    __subflavor__: Dict     # Sample metadata. Deprecated.
+    __subflavors__: List[Dict]  # Sample metadatas.
+    tokens: torch.Tensor  # Input tokens packed and padded (N, seq_len)
+    labels: torch.Tensor # Target tokens packed and padded (N, seq_len)
+    imgs: torch.Tensor  # All image tiles stacked into a single tensor (num_tiles, C, H, W)
+    num_tiles: List[List[int]]  # Number of tiles per image (N, num_imgs)
+    max_lengths: List[int]  # Maximum length across sub-samples (N,)
+    cu_lengths: List[List[int]]  # Cumulative length of each sub-sample in each packed sample of the batch (N, P)
+
+
+# Based on https://github.com/hiyouga/LLaMA-Factory/blob/641d0dab08d96a93c34657742213d8994d9ed476/src/llamafactory/data/processors/processor_utils.py#L19
+# Copyright (c) 2024 LLaMA-Factory. Apache license 2.0.
+def search_for_fit(numbers: List[int], capacity: int) -> int:
+    """Finds the index of largest number that fits into the knapsack with the given capacity."""
+    index = bisect.bisect(numbers, capacity)
+    return -1 if index == 0 else (index - 1)
+
+
+# Based on https://github.com/hiyouga/LLaMA-Factory/blob/641d0dab08d96a93c34657742213d8994d9ed476/src/llamafactory/data/processors/processor_utils.py#L27
+# Copyright (c) 2024 LLaMA-Factory. Apache license 2.0.
+def greedy_knapsack(item_sizes: List[int], samples: List, max_capacity: int) -> List:
+    """Greedy algorithm with binary search for the knapsack problem.
+
+    Pack as many samples as possible given a maximum capacity and capacities of individual samples.
+    Used if sequence packing is enabled.
+    """
+    assert len(item_sizes) == len(samples), "sample lengths and samples must have the same length."
+
+    knapsacks = []
+
+    if len(item_sizes) == 0:
+        return knapsacks
+
+    # Sort sample lengths and samples together.
+    sorted_item_sizes, sorted_samples = zip(*sorted(zip(item_sizes, samples), key=lambda x: x[0]))
+    sorted_item_sizes = list(sorted_item_sizes)
+    sorted_samples = list(sorted_samples)
+
+    # Check if all samples fit in the knapsack capacity.
+    if sorted_item_sizes[-1] > max_capacity:
+        raise ValueError(f"knapsack: A sample is larger {sorted_item_sizes[-1]} than the max_sequence_length {max_capacity}.")
+
+    while sorted_item_sizes:
+        current_knapsack = []
+        remaining_capacity = max_capacity
+
+        while True:
+            idx = search_for_fit(sorted_item_sizes, remaining_capacity)
+            if idx == -1:
+                break   # Can't fit more samples.
+
+            remaining_capacity -= sorted_item_sizes[idx]
+
+            sorted_item_sizes.pop(idx)
+            sample = sorted_samples.pop(idx)
+            current_knapsack.append(sample)
+
+        knapsacks.append(current_knapsack)
+
+    return knapsacks
+
+
+class TaskEncoder(DefaultTaskEncoder[OCRSample, OCRSample, ImageTaskBatchPacked, dict]):
+    """A simple task encoder for VLMs."""
+
+    def __init__(
+        self
+    ):
+        super().__init__()
+
+        self.args = get_args()
+
+        self.tokenizer = get_tokenizer()
+        with open(self.args.prompt_path, "r") as f:
+            self.manual_prompts = json.load(f)
+        self.dataloader_seq_length = self.args.dataloader_seq_length  # Always return samples of this length.
+        self.packing_seq_length = self.args.packing_seq_length     # Packing sequence length, if packing is enabled.
+        self.is_packing_enabled = self.args.packing_buffer_size is not None and self.args.packing_buffer_size > 0
+
+        if self.dataloader_seq_length and self.packing_seq_length:
+            assert self.dataloader_seq_length >= self.packing_seq_length, "dataloader sequence length must be greater than or equal to the packing sequence length"
+
+        if self.is_packing_enabled:
+            assert self.packing_seq_length > 0, "packing sequence length must be set"
+
+        self.num_image_embeddings_per_tile = get_num_image_embeddings(
+            self.args.img_h,
+            self.args.img_w,
+            self.args.patch_dim,
+            self.args.vision_model_type,
+            self.args.disable_vision_class_token,
+            1,
+            self.args.pixel_shuffle,
+            self.args.use_tile_tags,
+            self.args.max_num_tiles,
+            self.args.tokenizer_prompt_format,
+        )
+
+        self.txt_to_token_dict = {}
+
+        self.img_h, self.img_w = self.args.img_h, self.args.img_w
+        self.img_token_id = self.tokenizer.convert_tokens_to_ids(IMAGE_TOKEN)
+        # This map is used to reduce the number of tiles used per image if the number of tokens is
+        # larger than the decoder_seq_length.
+        self.num_tiles_degradation_map = {12:8, 8:6, 6:4, 4:2, 2:1, 1:1}
+
+        self.find_closest_aspect_ratio_fn = (
+            find_closest_area_weighted_aspect_ratio if self.args.use_area_weighted_aspect_ratio
+            else find_closest_aspect_ratio)
+
+        self.transform_img = ImageTransform(self.img_h, self.args.vision_model_type)
+
+    def _get_total_seq_length(self, input_ids, num_tiles):
+        """Calculate expected sequence length given text tokens length and number of tiles."""
+        total_num_images = len(num_tiles)
+        total_num_tiles = sum(num_tiles)
+        total_len = len(input_ids) + total_num_tiles * self.num_image_embeddings_per_tile - total_num_images
+        return total_len
+
+    def _truncate_for_packing(self, input_ids, target, num_tiles):
+        """Truncate tokens and labels if they exceed packing sequence length."""
+        total_num_images = len(num_tiles)
+        total_num_tiles = sum(num_tiles)
+        total_img_embeddings_len = total_num_tiles * self.num_image_embeddings_per_tile
+        max_text_tokens = self.packing_seq_length - total_img_embeddings_len + total_num_images
+
+        input_ids = input_ids[:max_text_tokens]
+        target = target[:max_text_tokens]
+
+        # If truncate causes all labels to be ignored, then skip the sample
+        if (target == IGNORE_INDEX).all():
+            raise ValueError(f"all targets will be ignored after truncation: {input_ids}")
+
+        return input_ids, target
+
+    @stateless(restore_seeds=True)
+    def encode_sample(self, sample: Union[CaptioningSample, OCRSample, VQASample, SimilarityInterleavedSample]):
+        if isinstance(sample, OCRSample):
+            if "pdfa" in sample.__key__:
+                yield self.combined_ocr_encoder(sample, task_type='encode_pdf')
+            elif "multi" in sample.__key__:
+                yield self.combined_ocr_encoder(sample, task_type='_encode_ocr')
+            else:
+                yield self.combined_ocr_encoder(sample, task_type='encode_ocr_ref')
+        elif isinstance(sample, CaptioningSample):
+            yield self.encode_captioning(sample)
+        elif isinstance(sample, VQASample):
+            is_llava_training = sample.__subflavors__["is_llava_training"] if "is_llava_training" in sample.__subflavors__ else False
+
+            if "llava" in sample.__key__ or is_llava_training:
+                yield self.encode_llava_pretrain(sample)
+            else:
+                yield self.encode_any_single_turn_vqa(sample)
+        elif isinstance(sample, SimilarityInterleavedSample):
+            yield self.encode_llava_sft(sample)
+        elif isinstance(sample, MultiChoiceVQASample):
+            yield self.encode_any_single_turn_vqa(sample)
+        # Because the SampleListSample is defined in the Megatron module but loaded by the Energon
+        # library, we need to resort to the more brittle check:
+        elif type(sample).__name__ == "SampleListSample":
+            yield self.encode_sample_list(sample)
+        else:
+            raise NotImplementedError("Sample format not supported", sample)
+
+    def encode_captioning(self, sample: CaptioningSample):
+        """Encode CaptioningSample."""
+        augment = sample.__subflavors__.get("augmentation")
+
+        imgs = self.transform_img(
+            sample.image, self.img_h, self.img_w, self.args.use_tiling, self.args.max_num_tiles, self.args.use_thumbnail, augment,
+            find_closest_aspect_ratio_fn=self.find_closest_aspect_ratio_fn
+        )
+        num_tiles = [len(imgs)]
+
+        prompt_list = self.manual_prompts["CaptioningPretraining"]["raw"]
+
+        prompt_idx = np.random.randint(len(prompt_list))
+        cur_prompt = prompt_list[prompt_idx]
+        cur_prompt = IMAGE_TOKEN + "\n" + cur_prompt + "\n"
+
+        caption = sample.caption.strip()
+
+        split_by_line_flag = sample.__subflavors__.get("SplitByLine")
+        if split_by_line_flag:
+            caption_list = caption.split('\n')
+            caption = np.random.choice(caption_list)
+
+        conv = [
+            # Note: no system message.
+            {"role": "user", "content": cur_prompt},
+            {"role": "assistant", "content": caption},
+        ]
+
+        input_ids, target = self.tokenizer.tokenize_conversation(conv, True, False)
+
+        if self.is_packing_enabled:
+            input_ids, target = self._truncate_for_packing(input_ids, target, num_tiles)
+
+        return ImageTaskSample(
+            __key__=sample.__key__,
+            __restore_key__=sample.__restore_key__,
+            __subflavor__=None,
+            __subflavors__=sample.__subflavors__,
+            imgs=imgs,
+            num_tiles=num_tiles,
+            tokens=torch.tensor(input_ids),
+            labels=torch.tensor(target),
+            total_len=self._get_total_seq_length(input_ids, num_tiles),
+        )
+
+    def encode_llava_pretrain(self, sample: VQASample):
+        """Encode pretrain sample in LLAVA style."""
+        augment = sample.__subflavors__.get("augmentation", False)
+
+        imgs = self.transform_img(
+            sample.image, self.img_h, self.img_w, self.args.use_tiling, self.args.max_num_tiles, self.args.use_thumbnail, augment,
+            find_closest_aspect_ratio_fn=self.find_closest_aspect_ratio_fn
+        )
+        num_tiles = [len(imgs)]
+
+        # LLAVA training: override text-prompt with just the image.
+        conv = [
+            # Note: no system message.
+            {"role": "user", "content": IMAGE_TOKEN + "\n"},
+            {"role": "assistant", "content": sample.answers},
+        ]
+
+        input_ids, target = self.tokenizer.tokenize_conversation(conv, True, False)
+
+        if self.is_packing_enabled:
+            input_ids, target = self._truncate_for_packing(input_ids, target, num_tiles)
+
+        return ImageTaskSample(
+            __key__=sample.__key__,
+            __restore_key__=sample.__restore_key__,
+            __subflavor__=None,
+            __subflavors__=sample.__subflavors__,
+            imgs=imgs,
+            num_tiles=num_tiles,
+            tokens=torch.tensor(input_ids),
+            labels=torch.tensor(target),
+            total_len=self._get_total_seq_length(input_ids, num_tiles),
+        )
+
+    def encode_sample_list(self, samples: SampleListSample):
+        """We encode the list of samples using encode_llava_sft on each sample."""
+        error_msg = ("You probably don't want to use online packing since SampleListSample is "
+                     "usually used along offline packing.")
+        assert not self.is_packing_enabled, error_msg
+        encoded_samples = []
+        current_length = 0
+        for idx, sample in enumerate(samples.samples):
+            try:
+                encoded_sample = self.encode_llava_sft(sample, truncate_for_sample_list_packing=True)
+                if current_length + encoded_sample.total_len > self.packing_seq_length:
+                    print(f"Encoding list of samples: stopped at {idx} samples to stick to {self.packing_seq_length}. Last sample key: {sample.__key__}")
+                    break
+                else:
+                    encoded_samples.append(encoded_sample)
+                    current_length += encoded_sample.total_len
+            except Exception as e:
+                print(e)
+        return self.pack_selected_samples(encoded_samples)
+
+    def encode_llava_sft(self, sample: Union[SimilarityInterleavedSample, OfflineTargetAspectRatioSample], truncate_for_sample_list_packing=False):
+        """Encode SFT sample."""
+        augment = sample.__subflavors__['augmentation'] if 'augmentation' in sample.__subflavors__ else False
+        has_video = sample.__subflavors__['has_video'] if 'has_video' in sample.__subflavors__ else False
+
+        # If the target aspect ratio are provided by the dataset, we use them instead of computing
+        # them with the self.find_closest_aspect_ratio_fn function.
+        local_find_closest_aspect_ratio_fn = self.find_closest_aspect_ratio_fn
+        if type(sample).__name__ == "OfflineTargetAspectRatioSample" and len(sample.target_aspect_ratio) > 0:
+            target_aspect_ratio = tuple(sample.target_aspect_ratio[0])
+            assert target_aspect_ratio is not None, "Sample of type OfflineTargetAspectRatioSample needs to define the target aspect ratio."
+            local_find_closest_aspect_ratio_fn = lambda *args, **kwargs: target_aspect_ratio
+
+        has_image = False
+        # We infer whether the sample has image or not.
+        if hasattr(sample, "images") and not has_video:
+            # If this is a text-only sample and we are freezing the LM,
+            # then use a dummy input image.
+            if len(sample.images) == 0 and self.args.freeze_LM:
+                empty_img = Image.new('RGB', (self.args.img_w, self.args.img_h), (255, 255, 255))
+                sample.images.append(empty_img)
+            if len(sample.images) > 0:
+                has_image = True
+
+        # Note: Some tokenizers may ignore the system prompt.
+        conversation = [{"role": "system", "content": "Answer the questions."}]
+        # Format the conversation as a list of "user" / "assistant" turns.
+        for text in sample.texts:
+            error_msg = f"unexpected role {text['from']} in {sample.texts}"
+            assert text["from"] in ["human", "gpt"], error_msg
+            conversation.append({
+                "role": "user" if text["from"] == "human" else "assistant",
+                "content": text["value"]})
+
+        # Replace the image tags <image-idx> with IMAGE_TOKEN and count the number of image tags
+        number_image_tags = 0
+        image_tag_ids_list = []
+        for turn in conversation:
+            if turn["role"] == "user":
+                image_tag_ids = [int(x) - 1 for x in re.findall(r"<image-(\d+)>", turn["content"])]
+                image_tag_ids_list.extend(image_tag_ids)
+                turn["content"] = re.sub(r"<image-\d+>", IMAGE_TOKEN, turn["content"])
+                # For videos, we use the image token to locate where to put the frames.
+                if has_video:
+                    turn["content"] = turn["content"].replace(VIDEO_TOKEN, IMAGE_TOKEN)
+                number_image_tags += turn["content"].count(IMAGE_TOKEN)
+
+        # We re-order the images in sample.images according to how they appear in the conversation.
+        if len(image_tag_ids_list) > 0:
+            sample.images = [sample.images[idx] for idx in image_tag_ids_list]
+
+        # If there is only one image, but several image tags, we assume all the tags refer to the
+        # same image and duplicate the image:
+        if not has_video and len(sample.images) == 1 and number_image_tags > 1:
+            sample.images = sample.images * number_image_tags
+
+        # If there are no images in the sample, remove the image tags in the conversation.
+        if len(sample.images) == 0:
+            for turn in conversation:
+                if turn["role"] == "user":
+                    turn["content"] = turn["content"].replace(IMAGE_TOKEN, "")
+            number_image_tags = 0
+
+        # We currently only support one video per sample.
+        number_of_images = 1 if has_video else len(sample.images)
+        # Fail if there are more image or video tags than image or videos:
+        error_msg = (
+            f"Found {number_image_tags} image tags for {number_of_images} images. {sample.texts}")
+        assert number_image_tags <= number_of_images, error_msg
+
+        # If there are less image of video tags than image or videos, prepend the tags to the first
+        # user message:
+        if number_image_tags < number_of_images:
+            for turn in conversation:
+                if turn["role"] == "user":
+                    turn["content"] = IMAGE_TOKEN*(number_of_images-number_image_tags) + "\n" + turn["content"]
+                    break
+
+        input_ids, target = self.tokenizer.tokenize_conversation(conversation, True, False)
+
+        if has_image:
+            imgs = []
+            num_tiles = []
+            max_num_tiles = self.args.max_num_tiles
+            # We keep a buffer of 4 tokens for the question,
+            # the rest can be used for image tokens.
+            max_image_token_allowed = self.args.decoder_seq_length - len(input_ids) - 4
+            # We start by extracting as many tiles per image as possible, and decrease the max
+            # number of tiles if there are too many image tokens.
+            while True:
+                imgs = []
+                num_tiles = []
+                for img in sample.images:
+                    # This if block is a temporary fix to handle video frames. We hard code
+                    # `use_tiling = False` because we don't use tiling for videos frames to keep
+                    # the number of tokens to a reasonable value.
+                    if isinstance(img, torch.Tensor) or isinstance(img, np.ndarray):
+                        if len(img.shape) == 4:
+                            assert img.shape[0] == 1, f"When len(img.shape) == 4, we expect the first dimension to be 1, but got img.shape: {img.shape} instead."
+                            img = img[0]
+                            use_tiling = False
+                        to_pil = ToPILImage()
+                        img = to_pil(img)
+                    img_tiles = self.transform_img(
+                        img, self.img_h, self.img_w, self.args.use_tiling, max_num_tiles,
+                        self.args.use_thumbnail, augment, find_closest_aspect_ratio_fn=local_find_closest_aspect_ratio_fn)
+                    imgs += img_tiles
+                    num_tiles += [len(img_tiles)]
+                if max_num_tiles == 1:
+                    break
+                if sum(num_tiles) * self.num_image_embeddings_per_tile > max_image_token_allowed:
+                    if max_num_tiles in self.num_tiles_degradation_map:
+                        max_num_tiles = self.num_tiles_degradation_map[max_num_tiles]
+                    else:
+                        raise RuntimeError((
+                            f"Tried to decrease the number of tiles {max_num_tiles} but it's not ",
+                            f"defined in the degradation map {self.num_tiles_degradation_map}"))
+                else:
+                    break
+        elif has_video:
+            # We don't use tiling for videos to limit the number of tokens.
+            use_tiling=False
+            # Grab the selected frames of the video as a tensor with shape
+            # fhwc: (num_frames, num_channels, height, width).
+            video_fchw = sample.images.frames
+            if video_fchw.shape[0] == 0:
+                raise ValueError(f"Video {sample.__key__} {sample.__restore_key__} {sample.texts} has no frames.")
+            selected_frames = torch.linspace(
+                0, video_fchw.shape[0] - 1,
+                min(self.args.num_frames, video_fchw.shape[0])).long()
+            video_fchw = video_fchw[selected_frames]
+            imgs = []
+            for video_chw in video_fchw:
+                to_pil = ToPILImage()
+                video_chw = to_pil(video_chw)
+                imgs += self.transform_img(
+                    video_chw, self.img_h, self.img_w, use_tiling, self.args.max_num_tiles,
+                    self.args.use_thumbnail, augment, find_closest_aspect_ratio_fn=local_find_closest_aspect_ratio_fn)
+            num_tiles = [len(imgs)]
+        else:
+            imgs = num_tiles = []
+
+        if self.is_packing_enabled or truncate_for_sample_list_packing:
+            input_ids, target = self._truncate_for_packing(input_ids, target, num_tiles)
+
+        # Some final checks with respect to the number of image tokens and images on the tokenized
+        # conversation. There can still be errors, for instance if a non-video sample happens to
+        # have our pre-defined video token, or if the packing truncation removed a necessary image
+        # tag.
+        number_image_token = np.sum(input_ids == self.img_token_id)
+        error_msg = (
+            f"Found {number_image_token} image tokens for len({num_tiles}) = {len(num_tiles)} image tiles in {conversation}.")
+        assert number_image_token == len(num_tiles), error_msg
+        error_msg = (
+            f"Found sum({num_tiles}) = {np.sum(num_tiles)} tiles for {len(imgs)} images in {conversation}.")
+        assert np.sum(num_tiles) == len(imgs), error_msg
+
+        # We need to ensure that there are at least some trainable tokens in the sample.
+        assert self.target_has_trainable_tokens(input_ids, num_tiles, target), "Sample has no trainable tokens."
+
+        # Context parallel requires padding.
+        total_len = self._get_total_seq_length(input_ids, num_tiles)
+        has_cp = self.args.context_parallel_size > 1
+
+        if has_cp:
+            # Note: FP8 requires padding only the total sequence length.
+            # We pad for FP8 when we have the final, possibly packed sample.
+            padding_needed = get_padding(total_len, self.args.context_parallel_size, self.args.tensor_model_parallel_size, self.args.sequence_parallel, fp8_enabled=False)
+            padding_input = np.ones(padding_needed) * self.tokenizer.pad
+            padding_labels = np.ones(padding_needed) * IGNORE_INDEX
+            input_ids = np.concatenate([input_ids, padding_input])
+            target = np.concatenate([target, padding_labels])
+            total_len = total_len + padding_needed
+
+        return ImageTaskSample(
+            __key__=sample.__key__,
+            __restore_key__=sample.__restore_key__,
+            __subflavor__=None,
+            __subflavors__=sample.__subflavors__,
+            imgs=imgs,
+            num_tiles=num_tiles,
+            tokens=torch.tensor(input_ids),
+            labels=torch.tensor(target),
+            total_len=self._get_total_seq_length(input_ids, num_tiles),
+        )
+
+    def target_has_trainable_tokens(self, input_ids, num_tiles, target):
+        # Compute the loss mask based on extending the image tags with the proper
+        # number of image tokens, extracting the first self.args.decoder_seq_length tokens, and
+        # ensuring that some of these tokens have a loss mask > 0.
+        # Note that this is a bit hacky because we reproduce here parts of the logics which are in
+        # the model itself. Ideally, the data sampler would return the already processed inputs
+        # and targets to avoid this duplication.
+        expanded_target = target.copy()
+        expanded_target[input_ids==self.img_token_id] = self.img_token_id
+        expanded_target = self.replace_value_with_repetition(
+            expanded_target, self.img_token_id,
+            self.num_image_embeddings_per_tile * np.array(num_tiles), IGNORE_INDEX)
+        loss_mask = torch.ones(torch.tensor(expanded_target).size(), dtype=torch.float)
+        loss_mask[expanded_target == self.tokenizer.pad] = 0.0 # mask paddings
+        loss_mask[expanded_target == IGNORE_INDEX] = 0.0 # mask prompts
+        loss_mask = torch.cat((loss_mask[1:], torch.zeros((1,))))
+        loss_mask = loss_mask[:self.args.decoder_seq_length]
+        return torch.sum(loss_mask) > 0
+
+    def replace_value_with_repetition(self, arr, token_to_replace, num_repetition, new_token):
+        """
+        Replace every occurrence of value V in the input array with R repetitions of W.
+
+        Args:
+            arr (Array): Input array to be modified
+            token_to_replace: token to be replaced
+            new_token: new token
+            num_repetition (Array): number of repetition of new token.
+
+        Returns:
+            Array: New array with token_to_replace replaced by num_repetition repetitions of
+             new_token
+        """
+        error_msg = "The number of image tokens must match the length of the tile tensor."
+        assert np.sum(arr==token_to_replace) == len(num_repetition), error_msg
+        result = []
+        idx = 0
+        for item in arr:
+            if item == token_to_replace:
+                # If the current item matches token_to_replace, add R copies of W
+                result.extend([new_token] * num_repetition[idx])
+                idx += 1
+            else:
+                # Otherwise, keep the original item
+                result.append(item)
+
+        return np.array(result)
+
+    def encode_any_single_turn_vqa(self, sample):
+        """Encode MultiChoiceVQA or VQA sample."""
+        augment = sample.__subflavors__['augmentation'] if 'augmentation' in sample.__subflavors__ else False
+        has_video = sample.__subflavors__['has_video'] if 'has_video' in sample.__subflavors__ else False
+
+        if has_video:
+            # Grab the selected frames of the video as a tensor with shape
+            # fhwc: (num_frames, height, width, num_channels).
+            video_fhwc = sample.image.permute(0, 2, 3, 1)
+            selected_frames = torch.linspace(
+                0, video_fhwc.shape[0] - 1, self.args.num_frames).long()
+            video_frame_fhwc = video_fhwc[selected_frames]
+            imgs = []
+            for video_frame_hwc in video_frame_fhwc:
+                imgs += self.transform_img(
+                    video_frame_hwc, self.img_h, self.img_w,
+                    self.args.use_tiling, self.args.max_num_tiles,
+                    self.args.use_thumbnail, augment, find_closest_aspect_ratio_fn=self.find_closest_aspect_ratio_fn
+                )
+        else:
+            imgs = self.transform_img(
+                sample.image, self.img_h, self.img_w, self.args.use_tiling, self.args.max_num_tiles,
+                self.args.use_thumbnail, augment, find_closest_aspect_ratio_fn=self.find_closest_aspect_ratio_fn
+            )
+
+        num_tiles = [len(imgs)]
+
+        if isinstance(sample, MultiChoiceVQASample):
+            cur_prompt = format_multichoice_question(sample.context, sample.choices)
+            if IMAGE_TOKEN not in cur_prompt:
+                cur_prompt = IMAGE_TOKEN + "\n" + cur_prompt
+            cur_answer = format_multichoice_answer(sample.correct_choice_idx)
+        elif isinstance(sample, VQASample):
+            if 'docvqa' in sample.__key__:
+                prompt_list = self.manual_prompts["VQASFT"]["docvqa"]
+            elif sample.__subflavors__.get("VQASFT"):
+                prompt_list = self.manual_prompts["VQASFT"]["raw"]
+            else:
+                prompt_list = ["{}"]
+
+            prompt_idx = np.random.randint(len(prompt_list))
+            cur_prompt = prompt_list[prompt_idx]
+
+            cur_prompt = cur_prompt.format(sample.context)
+
+            if IMAGE_TOKEN not in cur_prompt:
+                cur_prompt = IMAGE_TOKEN + "\n" + cur_prompt
+
+            if isinstance(sample.answers, list):
+                answer_list = sample.answers
+                weight_list = np.array(sample.answer_weights).astype(np.float32)
+                weight_list = weight_list / np.sum(weight_list)
+                answer_idx = np.random.choice(weight_list.shape[0], 1, p=weight_list)[0]
+                cur_answer = answer_list[answer_idx]
+            else:
+                cur_answer = sample.answers
+        else:
+            raise NotImplementedError("Unsupported data type provided", sample)
+
+        conversation = [
+            {"role": "system", "content": "Answer the questions."},
+            {"role": "user", "content": cur_prompt},
+            {"role": "assistant", "content": str(cur_answer)},
+        ]
+
+        input_ids, target = self.tokenizer.tokenize_conversation(conversation, True, False)
+
+        if self.is_packing_enabled:
+            input_ids, target = self._truncate_for_packing(input_ids, target, num_tiles)
+
+        return ImageTaskSample(
+            __key__=sample.__key__,
+            __restore_key__=sample.__restore_key__,
+            __subflavor__=None,
+            __subflavors__=sample.__subflavors__,
+            imgs=imgs,
+            num_tiles=num_tiles,
+            tokens=torch.tensor(input_ids),
+            labels=torch.tensor(target),
+            total_len=self._get_total_seq_length(input_ids, num_tiles),
+        )
+
+    def combined_ocr_encoder(self, sample, task_type):
+        """Encode OCR samples."""
+        augment = sample.__subflavors__['augmentation'] if 'augmentation' in sample.__subflavors__ else False
+
+        if task_type == "encode_pdf":
+            sample, cur_prompt, cur_answer = self.encode_pdf_prompt(sample)
+        elif task_type == "encode_ocr_ref":
+            sample, cur_prompt, cur_answer = self.encode_ocr_ref_prompt(sample)
+        elif task_type == "_encode_ocr":
+            sample, cur_prompt, cur_answer = self.encode_ocr_prompt(sample)
+
+        imgs = self.transform_img(
+                sample.image, self.img_h, self.img_w, self.args.use_tiling, self.args.max_num_tiles,
+                self.args.use_thumbnail, augment, find_closest_aspect_ratio_fn=self.find_closest_aspect_ratio_fn
+            )
+        num_tiles = [len(imgs)]
+
+        conversation = [
+            {"role": "system", "content": "Answer the questions."},
+            {"role": "user", "content": cur_prompt},
+            {"role": "assistant", "content": str(cur_answer)},
+        ]
+
+        input_ids, target = self.tokenizer.tokenize_conversation(conversation, True, False)
+
+        if self.is_packing_enabled:
+            input_ids, target = self._truncate_for_packing(input_ids, target, num_tiles)
+
+        return ImageTaskSample(
+            __key__=sample.__key__,
+            __restore_key__=sample.__restore_key__,
+            __subflavor__=None,
+            __subflavors__=sample.__subflavors__,
+            imgs=imgs,
+            num_tiles=num_tiles,
+            tokens=torch.tensor(input_ids),
+            labels=torch.tensor(target),
+            total_len=self._get_total_seq_length(input_ids, num_tiles),
+        )
+
+    def encode_pdf_prompt(self, sample: OCRSample) -> ImageTaskSample:
+        """Encode OCR sample."""
+        prompt_list = self.manual_prompts["DocPretraining"]["raw"]
+        prompt_idx = np.random.randint(len(prompt_list))
+        cur_prompt = prompt_list[prompt_idx]
+        if IMAGE_TOKEN not in cur_prompt:
+            cur_prompt = IMAGE_TOKEN + "\n" + cur_prompt
+
+        # Make sure there is no extra IMAGE_TOKEN tag.
+        sample.text = sample.text.replace(IMAGE_TOKEN, "")
+
+        caption = sample.text.strip()
+
+        split_by_line_flag = sample.__subflavors__.get("SplitByLine")
+        if split_by_line_flag:
+            caption_list = caption.split('\n')
+            caption = np.random.choice(caption_list)
+        cur_answer = caption
+
+        return sample, cur_prompt, cur_answer
+
+    def encode_ocr_ref_prompt(self, sample: OCRSample) -> ImageTaskSample:
+        """Encode OCR sample."""
+        ref = sample.text
+        region = sample.words_boxes
+
+        # Make sure there is no extra IMAGE_TOKEN tag
+        ref = ref.replace(IMAGE_TOKEN, "")
+
+        if len(region) == 4:
+            region = f"<box>({region[0]},{region[1]}),({region[2]},{region[3]})</box>"
+        else:
+            region = f"<quad>({region[0]},{region[1]}),({region[2]},{region[3]}),({region[4]},{region[5]}),({region[6]},{region[7]})</quad>"
+
+        # Randomly choose between two tasks
+        task_idx = np.random.randint(2)
+        if task_idx == 0:
+            # Referring Grounding
+            prompt_list = self.manual_prompts["DocPretraining"]["referring_grounding"]
+            prompt_content = ref
+            answer = region
+        else:
+            # Grounded OCR
+            prompt_list = self.manual_prompts["DocPretraining"]["grounded_ocr"]
+            prompt_content = region
+            answer = ref
+
+        prompt_idx = np.random.randint(len(prompt_list))
+        cur_prompt = prompt_list[prompt_idx]
+        cur_prompt = cur_prompt.format(prompt_content)
+        if IMAGE_TOKEN not in cur_prompt:
+            cur_prompt = IMAGE_TOKEN + "\n" + cur_prompt
+
+        return sample, cur_prompt, answer
+
+    def bbox_coord_to_label(self, text, bbox):
+        """Format bbox coordinates as text."""
+        assert len(bbox) == 4 or len(bbox) == 8
+
+        # Make sure there is no extra IMAGE_TOKEN tag
+        text = text.replace(IMAGE_TOKEN, "")
+
+        if len(bbox) == 4:
+            label_str = f"<ref>{text}</ref><box>({bbox[0]},{bbox[1]}),({bbox[2]},{bbox[3]})</box>"
+        else:
+            label_str = f"<ref>{text}</ref><quad>({bbox[0]},{bbox[1]}),({bbox[2]},{bbox[3]}),({bbox[4]},{bbox[5]}),({bbox[6]},{bbox[7]})</quad>"
+
+        return label_str
+
+    def encode_ocr_prompt(self, sample: OCRSample) -> ImageTaskSample:
+        """Encode OCR sample."""
+        if isinstance(sample.words_boxes[0], int):
+            answer = self.bbox_coord_to_label(sample.text, sample.words_boxes)
+        elif isinstance(sample.words_boxes[0], list):
+            answer = ""
+            for i, bbox in enumerate(sample.words_boxes):
+                answer += self.bbox_coord_to_label(sample.words_text[i], bbox)
+
+        prompt_list = self.manual_prompts["DocPretraining"]["ocr_multi"]
+        prompt_idx = np.random.randint(len(prompt_list))
+        cur_prompt = prompt_list[prompt_idx]
+
+        if IMAGE_TOKEN not in cur_prompt:
+            cur_prompt = IMAGE_TOKEN + "\n" + cur_prompt
+        cur_answer = answer
+
+        return sample, cur_prompt, cur_answer
+
+    def batch(self, samples: List[Union[ImageTaskSample, ImageTaskSamplePacked]]) -> ImageTaskBatchPacked:
+        # Stack images to [num_tiles, c, h, w]. If there are no images (text-only), then use a dummy image.
+        imgs = [img for s in samples for img in s.imgs]
+        if len(imgs) > 0:
+            imgs = torch.stack(imgs)
+        else:
+            imgs = torch.tensor([[0]], dtype=torch.float32)
+
+        # If the user hasn't defined a target dataloader sequence length, then use the max along the sample lengths.
+        max_seq_len = self.dataloader_seq_length
+        if not max_seq_len:
+           max_seq_len = max(len(s.tokens) for s in samples)
+
+        tokens = torch.full((len(samples), max_seq_len), self.tokenizer.pad, dtype=torch.int64)
+        # +1 to accommodate shift to left by one later.
+        labels = torch.full((len(samples), max_seq_len + 1), self.tokenizer.pad, dtype=torch.int64)
+
+        for i, s in enumerate(samples):
+            # If the sample/target length exceeds the target sequence length, then truncate.
+            text_len = min(max_seq_len, len(s.tokens))
+            target_len = min(max_seq_len+1, len(s.labels))
+
+            tokens[i, :text_len] = s.tokens[:text_len]
+            labels[i, :target_len] = s.labels[:target_len]
+
+        num_tiles = torch.tensor([n for s in samples for n in s.num_tiles], dtype=torch.int32)
+        if len(num_tiles) == 0:
+            num_tiles = torch.tensor([[0]], dtype=torch.int32)
+
+        # Cumulative sample lengths are needed for packing, otherwise use dummy values.
+        cu_lengths = torch.tensor([[0]], dtype=torch.int32)
+        max_lengths = torch.tensor([[0]], dtype=torch.int32)
+
+        is_packed = isinstance(samples[0], ImageTaskSamplePacked)
+
+        if is_packed:
+            cu_lengths = torch.stack([s.cu_lengths for s in samples])
+            max_lengths = torch.tensor([s.max_length for s in samples], dtype=torch.int32)
+
+        # Pad entire sequence to be a multiple of 32 or 16 if using fp8.
+        has_fp8 = self.args.fp8
+        if has_fp8:
+            total_seq_len = self._get_total_seq_length(tokens[0], num_tiles)
+            padding_needed = get_padding(
+                total_seq_len,
+                self.args.context_parallel_size,
+                self.args.tensor_model_parallel_size,
+                self.args.sequence_parallel,
+                fp8_enabled=has_fp8,
+                fp8_recipe=self.args.fp8_recipe,
+            )
+            if padding_needed > 0:
+                tokens = torch.cat([tokens, torch.full((tokens.shape[0], padding_needed), self.tokenizer.pad, dtype=torch.int64)], dim=1)
+                labels = torch.cat([labels, torch.full((labels.shape[0], padding_needed), IGNORE_INDEX, dtype=torch.int64)], dim=1)
+                if is_packed:
+                    cu_lengths[0][-1] += padding_needed
+                    new_max_length = cu_lengths[0][-1] - cu_lengths[0][-2]
+                    max_lengths = torch.max(max_lengths, new_max_length)
+
+
+        return ImageTaskBatchPacked(
+            __key__=[s.__key__ for s in samples],
+            __restore_key__=[s.__restore_key__ for s in samples],
+            __subflavor__=None,
+            __subflavors__=samples[0].__subflavors__,
+            tokens=tokens,
+            labels=labels,
+            imgs=imgs,
+            num_tiles=num_tiles,
+            cu_lengths=cu_lengths,
+            max_lengths=max_lengths,
+        )
+
+    def encode_batch(self, batch: ImageTaskBatchPacked) -> dict:
+        raw = dataclasses.asdict(batch)
+        del raw["__subflavors__"]
+        return raw
+
+    def select_samples_to_pack(self, samples: List[ImageTaskSample]) -> List[List[ImageTaskSample]]:
+        """Selects which samples will be packed together.
+
+        NOTE: Energon dataloader calls this method internally if packing is used.
+        Please see https://nvidia.github.io/Megatron-Energon/advanced/packing.html
+        """
+        lengths = [sample.total_len for sample in samples]
+
+        packed_samples = greedy_knapsack(lengths, samples, self.packing_seq_length)
+
+        return packed_samples
+
+    @stateless
+    def pack_selected_samples(self, samples: List[ImageTaskSample]) -> List[ImageTaskSamplePacked]:
+        """
+        Function to pack a list of ImageTaskSample into a single ImageTaskSamplePacked.
+
+        NOTE: Energon dataloader calls this method internally if packing is used.
+        Please see https://nvidia.github.io/Megatron-Energon/advanced/packing.html
+
+        Args:
+            samples: List of ImageTaskSample instances to pack into one sample.
+
+        Returns:
+            ImageTaskSamplePacked instance.
+        """
+        packing_seq_len = self.packing_seq_length
+
+        packed_tokens = []
+        packed_labels = []
+        packed_imgs = []
+
+        current_length = 0
+        max_length = 0
+        cu_lengths = [0]
+
+        # Process each sample and build lists that we will concatenate to create the packed sample.
+        for _, sample in enumerate(samples):
+            sample_len = sample.total_len
+
+            if sample_len > max_length:
+                max_length = sample_len
+
+            # If adding this sample exceeds the max length, stop.
+            # This should not happen. The select_samples_to_pack method should have already ensured that the samples fit.
+            if current_length + sample_len > packing_seq_len:
+                raise ValueError(f"Packed sample exceeds the maximum sequence length of {packing_seq_len}: {samples}")
+
+            # Add the sample's tokens and labels
+            packed_tokens.append(sample.tokens)
+            packed_labels.append(sample.labels)
+
+            # Add the images
+            packed_imgs += sample.imgs
+
+            current_length += sample_len
+            cu_lengths.append(current_length)
+
+        # Concatenate packed tokens and labels.
+        packed_tokens = torch.cat(packed_tokens, dim=0)
+        packed_labels = torch.cat(packed_labels, dim=0)
+
+        return ImageTaskSamplePacked(
+            __key__=",".join([s.__key__ for s in samples]),
+            __restore_key__=(),  # Will be set by energon based on `samples`
+            __subflavor__=None,
+            __subflavors__=samples[0].__subflavors__,
+            tokens=packed_tokens,
+            labels=packed_labels,
+            imgs=packed_imgs,
+            cu_lengths=torch.tensor(cu_lengths, dtype=torch.int32),
+            max_length=max_length,
+            num_tiles=[n for s in samples for n in s.num_tiles],
+        )
+
+
+def print_error_handler(exc: Exception, key: Optional[str]):
+    print(
+        f"The following exception occurred in the dataloader for sample {key} and is skipped",
+        file=sys.stderr,
+    )
+    traceback.print_exc()
+
+
+def format_multichoice_question(question, multichoice_options):
+    """Format multi-choice question."""
+    options_text = ["{}. {}\n".format(chr(ord('A') + i), option) for i, option in
+                    zip(range(len(multichoice_options)), multichoice_options)]
+    options_text = "".join(options_text)
+
+    options_text = f"{options_text}Answer with the option's letter from the given choices directly."
+
+    return "{}\n{}".format(question, options_text)
+
+
+def format_multichoice_answer(idx):
+    """Format multi-choice answer."""
+    return chr(ord('A') + idx)

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/energon_util.py

@@ -0,0 +1,31 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+import torch
+from dataclasses import dataclass
+from typing import Any, List
+
+from megatron.energon import Sample
+
+
+@dataclass
+class SampleListSample(Sample):
+    """Sample type for a list of samples of any type which needs to be packed together.
+
+    This is useful for datasets which are packed offline.
+    """
+
+    #: The images of the sequence
+    samples: List[Any]
+
+
+@dataclass
+class OfflineTargetAspectRatioSample(Sample):
+    """Sample type for image + text samples with target aspect ratio computed offline."""
+
+    #: The images of the sequence
+    images: List[torch.Tensor]
+    #: The texts of the sequence
+    texts: List[str]
+    target_aspect_ratio: List[List]
+
+    if not hasattr(Sample, "__subflavor__"):
+        __subflavor__: str

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/evaluation/evaluate_ai2d.py

@@ -0,0 +1,52 @@
+import argparse
+import json
+
+from .evaluate_mmmu import get_input_output_paths
+from .evaluate_vqav2 import compute_vqa_accuracy
+
+
+def merge_input_files(input_path):
+    """Merge input files to a format compatible with the evaluator."""
+    input_file_paths, output_file_path = get_input_output_paths(input_path, task="AI2D")
+
+    results = dict()
+
+    for input_file_path in input_file_paths:
+        with open(input_file_path, "r") as input_file:
+            for line in input_file:
+                res = json.loads(line)
+                sample_id = res["sample_id"]
+
+                # Ignore possible duplicates.
+                if sample_id in results:
+                    continue
+
+                results[sample_id] = {
+                    "question_id": sample_id,
+                    "answer": res["answer"],
+                    "gt_answer": res["gt_answer"],
+                }
+
+    results = list(results.values())
+
+    with open(output_file_path, "w") as output_file:
+        json.dump(results, output_file, indent=4, sort_keys=True)
+
+    return output_file_path
+
+
+def ai2d_eval(input_path):
+    """Run AI2D evaluation."""
+    result_file_path = merge_input_files(input_path)
+    avg_acc = compute_vqa_accuracy(result_file_path, task="AI2D")
+    return avg_acc
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--input-path', type=str, help="Path to input file(s)")
+    args = parser.parse_args()
+
+    avg_acc = ai2d_eval(args.input_path)
+
+    print(f"===== AI2D Accuracy {avg_acc:.2f}% =====")

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/evaluation/evaluate_coco.py

@@ -0,0 +1,67 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+import argparse
+import json
+
+from .evaluate_mmmu import get_input_output_paths
+from pycocoevalcap.eval import COCOEvalCap
+from pycocotools.coco import COCO
+
+
+def convert_to_coco_format(input_path):
+    """Convert input files to COCO compatible format."""
+    input_file_paths, output_file_path = get_input_output_paths(input_path, task="captioning")
+
+    results = dict()
+
+    for input_file_path in input_file_paths:
+        with open(input_file_path, "r") as input_file:
+            for line in input_file:
+                res = json.loads(line)
+                sample_id = res["sample_id"]
+
+                # Ignore possible duplicates.
+                if sample_id in results:
+                    continue
+
+                caption = res["caption"].rstrip(".").lower()
+                results[sample_id] = {
+                    "image_id": sample_id,
+                    "caption": caption,
+                }
+
+    results = list(results.values())
+
+    with open(output_file_path, "w") as output_file:
+        json.dump(results, output_file, indent=4, sort_keys=True)
+
+    return output_file_path
+
+
+def coco_captioning_eval(input_path, groundtruth_file):
+    """Run COCO captioning evaluation."""
+    coco = COCO(groundtruth_file)
+    input_file = convert_to_coco_format(input_path)
+    coco_result = coco.loadRes(input_file)
+
+    coco_eval = COCOEvalCap(coco, coco_result)
+
+    # Evaluate on the input subset of images.
+    coco_eval.params["image_id"] = coco_result.getImgIds()
+
+    coco_eval.evaluate()
+
+    print("========== COCO captioning scores ==========")
+    for metric, score in coco_eval.eval.items():
+        print(f"{metric} {score * 100:.3f}")
+
+    return coco_eval.eval['CIDEr']
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input-path", type=str, required=True, help="Path to input file(s)")
+    parser.add_argument(
+        "--groundtruth-path", type=str, required=True, help="Path to groundtruth file"
+    )
+    args = parser.parse_args()
+
+    coco_captioning_eval(args.input_path, args.groundtruth_path)