diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/gptoss/01_convert_from_hf.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/gptoss/01_convert_from_hf.py
new file mode 100644
index 0000000000000000000000000000000000000000..adee3358ec3c2866b77b2d20a163fa61525509f9
--- /dev/null
+++ b/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}")
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/gptoss/02_train.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/gptoss/02_train.sh
new file mode 100644
index 0000000000000000000000000000000000000000..d129adc2b845a1ff0adcb83bca87cc22cb14a335
--- /dev/null
+++ b/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[@]}
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/gptoss/03_convert_to_hf.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/gptoss/03_convert_to_hf.py
new file mode 100644
index 0000000000000000000000000000000000000000..8089afec854fd78e7fc52674bb71efe78ec49f27
--- /dev/null
+++ b/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}")
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/gptoss/README.md b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/gptoss/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..eeb92ad995313989a9936f04bd2472b0ac765135
--- /dev/null
+++ b/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
+```
\ No newline at end of file
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mamba/.gitignore b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mamba/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..940f4797e4b38d11f2ec6bed38a664e910ff9ae8
--- /dev/null
+++ b/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/
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mamba/Dockerfile b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mamba/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..2e194095b759e1c5e7f34340b716757c5d1a207d
--- /dev/null
+++ b/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
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mamba/README.md b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mamba/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..ce60f119ea544e188af00be8e18a1d9eea63d10e
--- /dev/null
+++ b/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.
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mamba/run_text_gen_server_8b.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mamba/run_text_gen_server_8b.sh
new file mode 100644
index 0000000000000000000000000000000000000000..d228e0c0edb75700544e47021d8133ca65745027
--- /dev/null
+++ b/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
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mamba/run_text_gen_server_8b_gpt3.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mamba/run_text_gen_server_8b_gpt3.sh
new file mode 100644
index 0000000000000000000000000000000000000000..5413b245ed3af0c6753bfc414e531231be386bc4
--- /dev/null
+++ b/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
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mamba/train.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mamba/train.sh
new file mode 100644
index 0000000000000000000000000000000000000000..ba83f0d4e3361435e817e52f71a3ecbad3a63357
--- /dev/null
+++ b/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}
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/__init__.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0519ecba6ea913e21689ec692e81e9e4973fbf73
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/__init__.py
@@ -0,0 +1 @@
+ 
\ No newline at end of file
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/avlm_inference.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/avlm_inference.py
new file mode 100644
index 0000000000000000000000000000000000000000..14ca2068cacf69cee82599635631148fcb7a4ea5
--- /dev/null
+++ b/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()
\ No newline at end of file
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/configs/llava_avlm.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/configs/llava_avlm.py
new file mode 100644
index 0000000000000000000000000000000000000000..f2c2d15ee1e9b5a7731fd764a36ef62cfb400065
--- /dev/null
+++ b/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,
+        ),
+    )
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/configs/llava_vlm.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/configs/llava_vlm.py
new file mode 100644
index 0000000000000000000000000000000000000000..21747e081de8b4a3aa00306f7526187d0586f0b5
--- /dev/null
+++ b/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,
+        ),
+    )
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/configs/mock.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/configs/mock.py
new file mode 100644
index 0000000000000000000000000000000000000000..c86d2e5a5865dbf1c65553b5b82db1b17dd3388c
--- /dev/null
+++ b/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),
+    )
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/data/__init__.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/data/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..df73bc4abd5f092819162037d1f6efd0a9d63642
--- /dev/null
+++ b/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,
+]
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/data/avlm_sample_loader.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/data/avlm_sample_loader.py
new file mode 100644
index 0000000000000000000000000000000000000000..d39cec6c29e660dce8d2a068f13a49da5c15d51b
--- /dev/null
+++ b/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
\ No newline at end of file
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/data/energon_avlm_task_encoder.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/data/energon_avlm_task_encoder.py
new file mode 100644
index 0000000000000000000000000000000000000000..a6a86761720fef7228e41bc13149383d24698a39
--- /dev/null
+++ b/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),
+} 
\ No newline at end of file
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/data/energon_vlm_task_encoder.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/data/energon_vlm_task_encoder.py
new file mode 100644
index 0000000000000000000000000000000000000000..18257fede7bcbad45304a18bbe7d48b38d7099be
--- /dev/null
+++ b/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(),
+}
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/data/mock.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/data/mock.py
new file mode 100644
index 0000000000000000000000000000000000000000..a1eaa0331752c2ffff71ba69847d17362f3088bd
--- /dev/null
+++ b/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
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/data/prepare_video_llava_data.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/data/prepare_video_llava_data.py
new file mode 100644
index 0000000000000000000000000000000000000000..4b33387f52cba451800f915bb7d6b073e32678f7
--- /dev/null
+++ b/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}")
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/data/utils/calculate_audio_tokens.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/data/utils/calculate_audio_tokens.py
new file mode 100644
index 0000000000000000000000000000000000000000..d40b563f66bfe2aed036af669133e2d01bd6ff1a
--- /dev/null
+++ b/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))
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/model_providers/__init__.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/model_providers/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0519ecba6ea913e21689ec692e81e9e4973fbf73
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/model_providers/__init__.py
@@ -0,0 +1 @@
+ 
\ No newline at end of file
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/model_providers/hf_clip_encoder.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/model_providers/hf_clip_encoder.py
new file mode 100644
index 0000000000000000000000000000000000000000..34583e4f1626e0f79981475b2f9cf1fc7e783908
--- /dev/null
+++ b/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
\ No newline at end of file
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/model_providers/hf_whisper_encoder.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/model_providers/hf_whisper_encoder.py
new file mode 100644
index 0000000000000000000000000000000000000000..2355e6a28fd405c78755f7bb17eb5180dd2bea55
--- /dev/null
+++ b/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
\ No newline at end of file
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/model_providers/llava_avlm.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/model_providers/llava_avlm.py
new file mode 100644
index 0000000000000000000000000000000000000000..bc1d554f9e1cef100b7a9149662c289fbf726200
--- /dev/null
+++ b/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
\ No newline at end of file
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/model_providers/llava_vlm.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/model_providers/llava_vlm.py
new file mode 100644
index 0000000000000000000000000000000000000000..e2de7e3f42cd9d27b2b5f9daee9b4d3c9cb90759
--- /dev/null
+++ b/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
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/model_providers/mock.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/model_providers/mock.py
new file mode 100644
index 0000000000000000000000000000000000000000..c4a71e2bf13f63ade60e5cabd26206af57fb07a0
--- /dev/null
+++ b/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
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/scripts/run_avlm_train.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/scripts/run_avlm_train.sh
new file mode 100644
index 0000000000000000000000000000000000000000..ced70cd0047ece641b319838911b1a21e3d68ae6
--- /dev/null
+++ b/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
\ No newline at end of file
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/scripts/run_mock_train.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/scripts/run_mock_train.sh
new file mode 100644
index 0000000000000000000000000000000000000000..2ed71cd5ede38dad3ae987bc325a0ecbf2f27a37
--- /dev/null
+++ b/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
\ No newline at end of file
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/scripts/run_video_vlm_train.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/scripts/run_video_vlm_train.sh
new file mode 100644
index 0000000000000000000000000000000000000000..2ec8af9d55fe41cefd4541ca1c128d3f413bed17
--- /dev/null
+++ b/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
\ No newline at end of file
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/scripts/run_vlm_train.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/scripts/run_vlm_train.sh
new file mode 100644
index 0000000000000000000000000000000000000000..31a13f3371ffc9d0fa82cda32c4d3a1cfac2a4d8
--- /dev/null
+++ b/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
+
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/train.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/train.py
new file mode 100644
index 0000000000000000000000000000000000000000..f4bab99d80fe753b7a6d7f24ba25b4cdef71ed32
--- /dev/null
+++ b/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,
+    )
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/utils/__init__.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/utils/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0519ecba6ea913e21689ec692e81e9e4973fbf73
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/utils/__init__.py
@@ -0,0 +1 @@
+ 
\ No newline at end of file
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/utils/data_helpers.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/utils/data_helpers.py
new file mode 100644
index 0000000000000000000000000000000000000000..e61f68bdacdc874b05cc3ea8ea4bb8769ae42e77
--- /dev/null
+++ b/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)
\ No newline at end of file
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/utils/logging.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/utils/logging.py
new file mode 100644
index 0000000000000000000000000000000000000000..dec06975c2d13e4cd990db341a2464a36e20a0f9
--- /dev/null
+++ b/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}")
\ No newline at end of file
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/utils/model_helpers.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mimo/utils/model_helpers.py
new file mode 100644
index 0000000000000000000000000000000000000000..2872158a9f1df4250930a41af34c5f8860993ebe
--- /dev/null
+++ b/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}"
+        )
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mixtral/README.md b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mixtral/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..e85eccd6efd14b2f052ec1a9ca9bb2cc75273234
--- /dev/null
+++ b/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>
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mixtral/train_mixtral_8x7b_distributed.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/mixtral/train_mixtral_8x7b_distributed.sh
new file mode 100644
index 0000000000000000000000000000000000000000..ed44d60f5c0363eb271ab7fbb02636cc6c82c0a9
--- /dev/null
+++ b/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[@]}
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/Dockerfile b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..d7c4fd41af5aaf5e9a18043e7fe5c2a20d0f5cc2
--- /dev/null
+++ b/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
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/README.md b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..824e7979fe9f02be6f21f81b0333bd7a12c1d17a
--- /dev/null
+++ b/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.
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/combine_lm_vision_checkpoints.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/combine_lm_vision_checkpoints.sh
new file mode 100644
index 0000000000000000000000000000000000000000..52de16ecd2337ea19502cf456f88992310618bb3
--- /dev/null
+++ b/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
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/combine_state_dicts.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/combine_state_dicts.py
new file mode 100644
index 0000000000000000000000000000000000000000..505d5e2271deb57c509a1dd47c1006245eac5afe
--- /dev/null
+++ b/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)
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/config.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/config.py
new file mode 100644
index 0000000000000000000000000000000000000000..bbca0fcb47a195af9454b757c19c23e0dc4443df
--- /dev/null
+++ b/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
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/convert_llava_pretrain_to_wds.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/convert_llava_pretrain_to_wds.py
new file mode 100644
index 0000000000000000000000000000000000000000..0092aef246eb5a3b92ec298313568af4befb3f5c
--- /dev/null
+++ b/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")
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/dataloader_provider.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/dataloader_provider.py
new file mode 100644
index 0000000000000000000000000000000000000000..b134debea5cb0b58f712e77c03e0ba277598cb52
--- /dev/null
+++ b/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
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/dataset_helpers.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/dataset_helpers.py
new file mode 100644
index 0000000000000000000000000000000000000000..2276cd858fa0499eacc5150fd22805b91af0de43
--- /dev/null
+++ b/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)
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/energon_util.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/energon_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..8406879ecec613d6654b8853a85dfb09b07e1a61
--- /dev/null
+++ b/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
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/evaluation/evaluate_ai2d.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/evaluation/evaluate_ai2d.py
new file mode 100644
index 0000000000000000000000000000000000000000..01ff4e8f48fb1474a00d53b807724d784135e471
--- /dev/null
+++ b/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}% =====")
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/evaluation/evaluate_coco.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/evaluation/evaluate_coco.py
new file mode 100644
index 0000000000000000000000000000000000000000..50031f3a5c42ceaa1731232beb2a650f4c283a3e
--- /dev/null
+++ b/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)
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/evaluation/evaluate_mmmu.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/evaluation/evaluate_mmmu.py
new file mode 100644
index 0000000000000000000000000000000000000000..2bdc2ebbdc56ab50317f37d05f094109cb069d4f
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/evaluation/evaluate_mmmu.py
@@ -0,0 +1,134 @@
+# Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+import argparse
+import glob
+import json
+import os
+import sys
+import re
+import subprocess
+
+from .mmmu_utils import parse_multi_choice_response
+# Get the absolute path of the parent directory
+parent_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), os.path.pardir))
+# Add the parent directory to sys.path
+sys.path.insert(0, parent_dir)
+
+from run_text_generation import get_output_path
+from config import EvaluationConfig
+
+
+
+def get_input_output_paths(input_path, task):
+    """Get all input files and an output path for a merged file."""
+    # Single input file.
+    if os.path.exists(input_path):
+        input_file_paths = [input_path]
+        output_file_path = input_path.replace(".jsonl", "-merged.json")
+    # Select multiple partitions and dp ranks.
+    else:
+        cfg = EvaluationConfig(task=task, output_path=input_path, partition_id="*")
+        pattern = get_output_path(cfg, dp_rank="*")
+        input_file_paths = glob.glob(pattern)
+
+        output_file_path = input_path + f"-{task}-merged.json"
+
+    return input_file_paths, output_file_path
+
+
+def extract_answer(text):
+    import re
+    # Regular expression to find content inside \answer{xxx}
+    match = re.search(r'\\answer\{(.*?)\}', text)
+    if match:
+        return match.group(1)  # Return the content inside the braces
+
+    # Regular expression to find content inside \boxed{xxx}
+    match = re.search(r'\\boxed\{(.*?)\}', text)
+    if match:
+        return match.group(1)  # Return the content inside the braces
+
+    text = text.replace("Answer:", "Answer: ")
+    return text  # Return the original string if no match is found
+
+
+
+def convert_to_mmmu_format(input_path):
+    """Convert input files to MMMU compatible format."""
+    input_file_paths, output_file_path = get_input_output_paths(input_path, "MMMU")
+
+    output = 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"]
+                prediction = res["prediction"]
+
+                if sample_id in output:
+                    continue
+
+                if res["question_type"] == "multiple-choice":
+                    prediction = extract_answer(prediction)
+                    prediction = parse_multi_choice_response(
+                        prediction, res["all_choices"], res["index2ans"]
+                    )
+
+                # MMMU eval script expects just a sample_id to prediction mapping.
+                output[sample_id] = prediction
+
+    with open(output_file_path, "w") as output_file:
+        json.dump(output, output_file, indent=4, sort_keys=True)
+
+    return output_file_path
+
+
+def mmmu_eval(input_path, groundtruth_path):
+    """Run MMMU evaluation."""
+    result_file = convert_to_mmmu_format(input_path)
+
+    # The MMMU repo has a script for running the actual evaluation but no API. So launching the script here.
+    output = subprocess.run(
+        [
+            "python",
+            "examples/multimodal/MMMU/mmmu/main_eval_only.py",
+            "--output_path",
+            result_file,
+            "--answer_path",
+            groundtruth_path,
+        ],
+        capture_output=True,
+        text=True,
+    )
+
+    print(output.stderr)
+    print(output.stdout)
+
+    m = re.search(r"'Overall': {'num': \d+, 'acc': (\d\.\d+)}", output.stdout)
+
+    return float(m.group(1)) * 100.0
+
+
+def main():
+    """Run MMMU evaluation."""
+    # Using the validation groundtruth file from the MMMU repo by default. This assumes you have cloned the MMMU github repo here.
+    default_groundtruth_path = "examples/multimodal/MMMU/mmmu/answer_dict_val.json"
+
+    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,
+        default=default_groundtruth_path,
+        help="Path to groundtruth file. Defaults to the validation file in the MMMU repo.",
+    )
+    args = parser.parse_args()
+
+    avg_acc = mmmu_eval(args.input_path, args.groundtruth_path)
+
+    print(f"MMMU average accuracy: {avg_acc:.2f}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/evaluation/evaluate_realworldqa.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/evaluation/evaluate_realworldqa.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ef78d047e33a596ea0b116b7118139faf711a19
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/evaluation/evaluate_realworldqa.py
@@ -0,0 +1,45 @@
+import argparse
+import json
+
+from .evaluate_vqav2 import compute_vqa_accuracy
+from .evaluate_mmmu import get_input_output_paths
+
+
+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="RealworldQA")
+
+    results = []
+    collected = set()
+
+    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)
+                res["question_id"] = res["sample_id"]
+                if res['sample_id'] in collected:
+                    continue
+                collected.add(res['sample_id'])
+
+                results.append(res)
+
+    with open(output_file_path, "w") as output_file:
+        json.dump(results, output_file, indent=4, sort_keys=True)
+
+    return output_file_path
+
+
+def realworldqa_eval(input_path):
+    """Run RealWorldQA evaluation."""
+    result_file_path = merge_input_files(input_path)
+    return compute_vqa_accuracy(result_file_path, task="RealworldQA")
+
+
+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 = realworldqa_eval(args.input_path)
+
+    print(f"RealworldQA accuracy: {avg_acc:.2f}")
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/evaluation/evaluate_spdocvqa.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/evaluation/evaluate_spdocvqa.py
new file mode 100644
index 0000000000000000000000000000000000000000..57a5c237af5aa99736e956358eacebd35f45ca3f
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/evaluation/evaluate_spdocvqa.py
@@ -0,0 +1,48 @@
+import argparse
+import json
+
+from .evaluate_vqav2 import compute_vqa_accuracy
+from .evaluate_mmmu import get_input_output_paths
+
+
+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="SPDocVQA")
+
+    results = []
+
+    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)
+                results.append(
+                    {
+                        "question_id": res["sample_id"],
+                        "answer": res["answer"],
+                        "gt_answer": res["gt_answer"],
+                    }
+                )
+
+    # Make order deterministic.
+    # results = sorted(results, key=lambda d: d["question_id"])
+
+    with open(output_file_path, "w") as output_file:
+        json.dump(results, output_file)
+
+    return output_file_path
+
+
+def spdocvqa_eval(input_path):
+    """Run SPDocVQA evaluation."""
+    result_file_path = merge_input_files(input_path)
+    return compute_vqa_accuracy(result_file_path, task="SPDocVQA")
+
+
+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 = spdocvqa_eval(args.input_path)
+
+    print(f"===== SPDocVQA Accuracy {avg_acc:.2f}% =====")
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/evaluation/evaluate_video_motionbench.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/evaluation/evaluate_video_motionbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..7d6db0354e257433b569db517306f14a633f17fe
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/evaluation/evaluate_video_motionbench.py
@@ -0,0 +1,45 @@
+import argparse
+import json
+
+
+from .evaluate_vqav2 import compute_vqa_accuracy
+from .evaluate_mmmu import get_input_output_paths
+
+
+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="MotionBench")
+
+    results = []
+    collected = set()
+
+    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)
+                res["question_id"] = res["sample_id"]
+                if res['sample_id'] in collected:
+                    continue
+                collected.add(res['sample_id'])
+
+                results.append(res)
+
+    with open(output_file_path, "w") as output_file:
+        json.dump(results, output_file, indent=4, sort_keys=True)
+
+    return output_file_path
+
+
+def motionbench_eval(input_path):
+    result_file_path = merge_input_files(input_path)
+    return compute_vqa_accuracy(result_file_path, task="MotionBench")
+
+
+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 = motionbench_eval(args.input_path)
+
+    print(f"MotionBench accuracy: {avg_acc:.2f}")
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/evaluation/evaluate_video_phys_game_bench.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/evaluation/evaluate_video_phys_game_bench.py
new file mode 100644
index 0000000000000000000000000000000000000000..feb4c5581204046038a1194ea52f73600ae7b1b3
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/evaluation/evaluate_video_phys_game_bench.py
@@ -0,0 +1,98 @@
+import argparse
+import json
+
+from .evaluate_mmmu import get_input_output_paths
+
+
+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="PhysGameBench")
+
+    results = []
+    collected = set()
+
+    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)
+                res["question_id"] = res["sample_id"]
+                if res['sample_id'] in collected:
+                    continue
+                collected.add(res['sample_id'])
+
+                results.append(res)
+
+    with open(output_file_path, "w") as output_file:
+        json.dump(results, output_file, indent=4, sort_keys=True)
+
+    return output_file_path
+
+
+# The following function is adapted from
+# https://github.com/PhysGame/PhysGame/blob/main/physvlm/test/PhysGame_bench/utils.py#L101
+# which is licensed under the Apache 2.0 license. More details on the license can be
+# found at https://github.com/PhysGame/PhysGame/tree/main?tab=Apache-2.0-1-ov-file#readme
+def check_ans(pred, gt):
+    flag = False
+    
+    pred_list = pred.lower().split(' ')
+    pred_option, pred_content = pred_list[0], ' '.join(pred_list[1:])
+    gt_list = gt.lower().split(' ')
+    gt_option, gt_content = gt_list[0], ' '.join(gt_list[1:])
+    if gt_content[-1] == '.':
+        gt_content = gt_content[:-1]
+    
+    if pred_option.replace('.', '') in gt_option:
+        flag = True
+    elif gt_option in pred_option:
+        flag = True
+        
+    return flag
+
+def compute_all_acc(result_list):
+    correct, total = 0, 0
+    subclass_cnt = {}
+    for res in result_list:
+        total += 1
+        pred = res['answer']
+        gt = res['gt_answer'][0]
+        subclass = res['subclass']
+        if gt.lower().replace(".", "") == pred.lower().replace(".", ""):
+            correct += 1
+            if subclass not in subclass_cnt.keys():
+                subclass_cnt.update({subclass: [1, 1]})
+            else:
+                subclass_cnt[subclass][0] += 1
+                subclass_cnt[subclass][1] += 1
+        else:
+            if subclass not in subclass_cnt.keys():
+                subclass_cnt.update({subclass: [0, 1]})
+            else:
+                subclass_cnt[subclass][1] += 1
+    
+    result_acc_dict = {
+        "Physgame-Total-Acc": correct / total * 100
+    }
+    print (f'Physgame-Total-Acc: {correct / total * 100 :.2f}%', )
+    for sub_i in subclass_cnt.keys():
+        print(f'Physgame-{sub_i}-Acc: {subclass_cnt[sub_i][0] / subclass_cnt[sub_i][1] * 100 :.2f}%')
+        result_acc_dict[f'Physgame-{sub_i}-Acc'] = subclass_cnt[sub_i][0] / subclass_cnt[sub_i][1] * 100
+    
+    return result_acc_dict
+        
+def phys_game_bench_eval(input_path):
+    result_file_path = merge_input_files(input_path)
+    
+    merged_results = json.load(open(result_file_path))
+    
+    return compute_all_acc(merged_results)
+
+
+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 = phys_game_bench_eval(args.input_path)
+
+    print(f"PhysGameBench accuracy: {avg_acc:.2f}")
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/evaluation/evaluation_datasets.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/evaluation/evaluation_datasets.py
new file mode 100644
index 0000000000000000000000000000000000000000..ebf0e2e15eeef94b08f4f99f8ab0b29eebfe4c2c
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/evaluation/evaluation_datasets.py
@@ -0,0 +1,1698 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+"""Evaluation datasets."""
+import glob
+import json
+import os
+import re
+from collections import defaultdict
+
+import numpy as np
+import torch
+from image_processing import ImageTransform
+from PIL import Image
+
+from megatron.training import print_rank_0
+
+
+def _get_partition_bounds(
+    total_num_samples, num_samples_per_partition, num_partitions, partition_id
+):
+    if num_samples_per_partition == 0:
+        samples_per_partition = [
+            int(x) for x in np.linspace(0, total_num_samples, num_partitions + 1)
+        ]
+        return samples_per_partition[partition_id], samples_per_partition[partition_id + 1]
+    return num_samples_per_partition * partition_id, num_samples_per_partition * (partition_id + 1)
+
+
+class VQADataset(torch.utils.data.Dataset):
+    """VQA evaluation dataset."""
+
+    def __init__(
+        self,
+        input_image_path,
+        gt_path,
+        num_samples_per_partition,
+        num_partitions,
+        partition_id,
+        keys,
+        img_h,
+        img_w,
+        use_tiling,
+        max_num_tiles,
+        use_thumbnail,
+        vision_model_type,
+        split="validation"
+    ):
+        samples = json.load(open(gt_path, encoding='utf-8'))
+        if "data" in samples:
+            samples = samples["data"]
+
+        # Optionally, process only a subset of the input files.
+        if num_partitions > 0:
+            lb, ub = _get_partition_bounds(
+                len(samples), num_samples_per_partition, num_partitions, partition_id
+            )
+            samples = samples[lb:ub]
+
+        self._keys = keys
+        self._samples = samples
+        self._input_image_path = input_image_path
+        self._img_h = img_h
+        self._img_w = img_w
+        self._use_tiling = use_tiling
+        self._max_num_tiles = max_num_tiles
+        self._use_thumbnail = use_thumbnail
+        self._transform_img = ImageTransform(img_h, vision_model_type)
+        self._split = split
+
+    def __len__(self):
+        return len(self._samples)
+
+    def __getitem__(self, idx):
+        sample = self._samples[idx]
+
+        img_file = "{}/{}".format(self._input_image_path, sample[self._keys["image_id"]])
+        if not os.path.exists(img_file):
+            img_file += ".jpg"
+
+            if not os.path.exists(img_file):
+                img_file = img_file.replace('.jpg', '.png')
+
+        img = Image.open(img_file)
+        imgs = self._transform_img(
+            img,
+            self._img_h,
+            self._img_w,
+            self._use_tiling,
+            self._max_num_tiles,
+            self._use_thumbnail,
+            augment=False,
+        )
+        tile_count = torch.tensor([len(imgs)], dtype=torch.int)
+
+        sample_id = idx
+        if "sample_id" in self._keys:
+            sample_id = sample[self._keys["sample_id"]]
+
+        metadata = ""  # Not used.
+
+        return (
+            torch.stack(imgs),
+            tile_count,
+            sample_id,
+            sample[self._keys["question"]],
+            [""] if self._split == "test" else sample[self._keys["answer"]],
+            metadata,
+        )
+
+
+class CaptioningDataset(torch.utils.data.Dataset):
+    """Captioning evaluation dataset."""
+
+    def __init__(
+        self,
+        input_image_path,
+        gt_path,
+        num_samples_per_partition,
+        num_partitions,
+        partition_id,
+        img_h,
+        img_w,
+        use_tiling,
+        max_num_tiles,
+        use_thumbnail,
+        vision_model_type,
+    ):
+        image_files = sorted(glob.glob(input_image_path + "/*"))
+
+        # Optionally, process only a subset of the input files.
+        if num_partitions > 0:
+            lb, ub = _get_partition_bounds(
+                len(image_files), num_samples_per_partition, num_partitions, partition_id
+            )
+            image_files = image_files[lb:ub]
+
+        gts = json.load(open(gt_path))
+        answers = defaultdict(list)
+        for gt in gts["annotations"]:
+            answers[gt["image_id"]].append(gt['caption'])
+
+        self._image_files = image_files
+        self._answers = answers
+        self._img_h = img_h
+        self._img_w = img_w
+        self._use_tiling = use_tiling
+        self._max_num_tiles = max_num_tiles
+        self._use_thumbnail = use_thumbnail
+        self._transform_img = ImageTransform(img_h, vision_model_type)
+
+    def __len__(self):
+        return len(self._image_files)
+
+    def __getitem__(self, idx):
+        img_file = self._image_files[idx]
+        try:
+            image_id = int(img_file.split("_")[-1].split(".")[0])  # coco
+        except:
+            image_id = int(img_file.split("/")[-1].split(".")[0])  # flickr
+
+        img = Image.open(img_file)
+        imgs = self._transform_img(
+            img,
+            self._img_h,
+            self._img_w,
+            self._use_tiling,
+            self._max_num_tiles,
+            self._use_thumbnail,
+            augment=False,
+        )
+
+        tile_count = torch.tensor([len(imgs)], dtype=torch.int)
+
+        question = ""  # Fixed for all samples.
+        metadata = ""  # Not used.
+
+        return torch.stack(imgs), tile_count, image_id, question, self._answers[image_id], metadata
+
+
+class MMMUDataset(torch.utils.data.Dataset):
+    """MMMU evaluation dataset."""
+
+    def __init__(
+        self,
+        input_image_path,
+        num_samples_per_partition,
+        num_partitions,
+        partition_id,
+        img_h,
+        img_w,
+        use_tiling,
+        max_num_tiles,
+        use_thumbnail,
+        prompt_style,
+        vision_model_type,
+        split="validation",
+    ):
+        import datasets
+        from .mmmu_utils import CAT_SHORT2LONG, load_yaml
+
+        # The following downloads the MMMU dataset from HuggingFace and uses the API from the MMMU github repo to run MMMU evaluation.
+        all_mmmu_datasets = []
+
+        hf_datasets_cache = os.environ["HF_DATASETS_CACHE"]
+        assert hf_datasets_cache != "", "Please set the environment variable HF_DATASETS_CACHE."
+
+        for subject in CAT_SHORT2LONG.values():
+            # Use a local copy of the dataset if exists (can be faster) or the HF one.
+            if os.path.exists(input_image_path):
+                subject_dataset = datasets.load_dataset(
+                    os.path.join(input_image_path, subject),
+                    split=split,
+                    cache_dir=hf_datasets_cache,
+                    verification_mode="no_checks",
+                )
+            else:
+                subject_dataset = datasets.load_dataset(
+                    "MMMU/MMMU",
+                    subject,
+                    split=split,
+                    cache_dir=hf_datasets_cache,
+                )
+
+            all_mmmu_datasets.append(subject_dataset)
+
+        dataset = datasets.concatenate_datasets(all_mmmu_datasets)
+
+        dataset = [s for s in dataset if s['id'].startswith("val")]
+
+        # Optionally, process only a subset of the input files.
+        if num_partitions > 0:
+            lb, ub = _get_partition_bounds(
+                len(dataset), num_samples_per_partition, num_partitions, partition_id
+            )
+            dataset = dataset[lb:ub]
+
+        # Using the LLaVA config from the MMMU repo.
+        config = load_yaml("examples/multimodal/MMMU/mmmu/configs/llava1.5.yaml")
+        for k, v in config.items():
+            if isinstance(v, list):
+                assert len(v) == 1, "only one value supported."
+                config[k] = v[0]
+
+        self._config = config
+
+        self._dataset = dataset
+
+        self._img_h = img_h
+        self._img_w = img_w
+        self._use_tiling = use_tiling
+        self._max_num_tiles = max_num_tiles
+        self._use_thumbnail = use_thumbnail
+        self._prompt_style = prompt_style
+        self._transform_img = ImageTransform(img_h, vision_model_type)
+
+    def __len__(self):
+        return len(self._dataset)
+
+    def process_image_tag(self, q):
+        q = q.strip()
+
+        # heuristic way of removing <image 1>
+        if q == '<image 1>':
+            q = 'Answer the question in the image.'
+        elif ':<image 1>' in q:
+            q = q.replace(':<image 1>', ' in the image. ')
+            q = q.strip()
+        elif ': <image 1>' in q:
+            q = q.replace(': <image 1>', ' in the image. ')
+            q = q.strip()
+        elif '.<image 1>' in q or '. <image 1>' in q:
+            q_list = q.split('<image 1>')
+            q_list = [part.strip() for part in q_list if part.strip() != '']
+            q = ' '.join(q_list)
+        elif q.startswith('<image 1> '):
+            if q[10].isupper():
+                q = q.replace('<image 1>', '')
+            else:
+                q = q.replace('<image 1>', 'The image')
+            q = q.strip()
+        elif q.startswith('<image 1>'):
+            q = q.replace('<image 1>', '')
+        elif q.endswith('<image 1>?'):
+            q = q.replace('<image 1>', 'the image')
+        elif q.endswith('?<image 1>') or q.endswith('? <image 1>') or q.endswith('\n<image 1>'):
+            q = q.replace('<image 1>', '')
+            q = q.strip()
+        elif ' <image 1> ' in q:
+            q = q.replace('<image 1>', 'the image')
+        elif ' <image 1>' in q:
+            q = q.replace('<image 1>', 'the image')
+        elif '()<image 1>' in q:
+            q = q.replace('()<image 1>', '')
+        elif '(<image 1>)' in q:
+            q = q.replace('(<image 1>)', '')
+        elif '<image 1>.' in q:
+            q = q.replace("<image 1>.", ". ")
+        else:
+            q = q.replace("<image 1>", ". ")
+            q = q.strip()
+
+        # remove <image 2> to <image 8>
+        for i in range(2, 8):
+            q = q.replace(f"<image {i}>", "")
+
+        return q
+
+    def __getitem__(self, idx):
+        from .mmmu_utils import construct_prompt, process_single_sample
+
+        sample = self._dataset[idx]
+
+        # Use the single image approach from the MMMU repo.
+        if self._prompt_style == "single_image":
+            sample = process_single_sample(sample)
+            sample = construct_prompt(sample, self._config)
+
+            img = sample["image"]
+            sample_imgs = self._transform_img(
+                img,
+                self._img_h,
+                self._img_w,
+                self._use_tiling,
+                self._max_num_tiles,
+                self._use_thumbnail,
+                augment=False,
+            )
+            sample_num_tiles = [len(sample_imgs)]
+
+            prompt = sample["final_input_prompt"]
+            sample["final_input_prompt"] = self.process_image_tag(prompt)
+        elif self._prompt_style == "vlmevalkit":
+            sample = construct_prompt(sample, self._config)
+
+            if sample["question_type"] == "multiple-choice":
+                question = sample["question"]
+
+                options = ""
+                for k, v in sample["index2ans"].items():
+                    options += f"{k}. {v}\n"
+
+                final_prompt = f"{question}\n"
+                if "hint" in sample:
+                    final_prompt += f"Hint: {sample['hint']}\n"
+
+                if "task_instructions" in sample:
+                    final_prompt += f"Task instructions: {sample['task_instructions']}\n"
+
+                final_prompt += options
+                final_prompt += "Answer with the option's letter from the given choices directly."
+
+                sample["final_input_prompt"] = final_prompt.rstrip()
+            else:
+                question = sample["question"]
+                final_prompt = f"{question}\n"
+                final_prompt += "Answer the question directly."
+                sample["final_input_prompt"] = final_prompt.rstrip()
+
+            sample_imgs = []
+            sample_num_tiles = []
+
+            img_indices = sorted(list(set(re.findall(r"<image (\d+)", sample["final_input_prompt"]))))
+            # If there are multiple input images, we need to avoid the number of image embeddings getting too large.
+            adjusted_max_num_tiles = max(1, self._max_num_tiles // len(img_indices))
+            adjusted_max_num_tiles = min(adjusted_max_num_tiles, self._max_num_tiles)
+
+            for img_idx in img_indices:
+                img_key = f"image_{img_idx}"
+                img_str = f"<image {img_idx}>"
+
+                img = sample[img_key]
+                assert img is not None, f"{img_str} is in prompt but not in sample images"
+
+                imgs = self._transform_img(
+                    img,
+                    self._img_h,
+                    self._img_w,
+                    self._use_tiling,
+                    adjusted_max_num_tiles,
+                    self._use_thumbnail,
+                    augment=False,
+                )  # List of tiles.
+
+                sample_imgs.extend(imgs)
+                sample_num_tiles.append(len(imgs))
+
+            sample["final_input_prompt"] = " ".join([f'<image {i + 1}><image>' for i in range(len(img_indices))]) + "\n" + sample["final_input_prompt"]
+        elif self._prompt_style == "multi_image":
+            sample = construct_prompt(sample, self._config)
+
+            sample_imgs = []
+            sample_num_tiles = []
+
+            img_indices = re.findall(r"<image (\d+)", sample["final_input_prompt"])
+            # If there are multiple input images, we need to avoid the number of image embeddings getting too large.
+            adjusted_max_num_tiles = max(1, self._max_num_tiles // len(img_indices))
+
+            for img_idx in img_indices:
+                img_key = f"image_{img_idx}"
+                img_str = f"<image {img_idx}>"
+
+                img = sample[img_key]
+                assert img is not None, f"{img_str} is in prompt but not in sample images"
+
+                # Note: Only replace the current image tag.
+                sample["final_input_prompt"] = sample["final_input_prompt"].replace(
+                    img_str, "<image>", 1
+                )
+
+                imgs = self._transform_img(
+                    img,
+                    self._img_h,
+                    self._img_w,
+                    self._use_tiling,
+                    adjusted_max_num_tiles,
+                    self._use_thumbnail,
+                    augment=False,
+                )  # List of tiles.
+
+                sample_imgs.extend(imgs)
+                sample_num_tiles.append(len(imgs))
+
+            # Sanity check.
+            for i in range(1, 8):
+                assert (
+                    f"<image {i}>" not in sample["final_input_prompt"]
+                ), "prompt contains unhandled image tags"
+        else:
+            raise ValueError(f"unknown prompt style {self._prompt_style}")
+
+        # MMMU specific metadata.
+        metadata = {"question_type": sample["question_type"],
+                    "field": sample["field"],
+                    "subfield": sample["subfield"]}
+        if sample["question_type"] == "multiple-choice":
+            metadata["index2ans"] = sample["index2ans"]
+            metadata["all_choices"] = sample["all_choices"]
+
+        prompt = sample['final_input_prompt']
+
+        tile_count = torch.tensor(sample_num_tiles, dtype=torch.int)
+
+        return (
+            torch.stack(sample_imgs),
+            tile_count,
+            sample["id"],
+            prompt,
+            sample["answer"],
+            metadata,
+        )
+
+
+class VideoMMEDataset(torch.utils.data.Dataset):
+    "Video MME evaluation dataset."
+
+    def __init__(
+        self,
+        input_image_path,
+        gt_path,
+        num_samples_per_partition,
+        num_partitions,
+        partition_id,
+        img_h,
+        img_w,
+        use_tiling,
+        max_num_tiles,
+        use_thumbnail,
+        num_frames,
+        vision_model_type,
+    ):
+        ground_truth_original = json.load(open(gt_path))
+        ground_truth = []
+        for gt in ground_truth_original:
+            video_path = gt["url"]
+            video_path = video_path.replace("https://www.youtube.com/watch?v=", "")
+            video_path = video_path.replace("https://m.youtube.com/watch?v=", "")
+            video_path = os.path.join(input_image_path, video_path + ".mp4")
+            if not os.path.exists(video_path):
+                continue
+            gt["video_path"] = video_path
+            ground_truth.append(gt)
+
+        ground_truth = sorted(ground_truth, key=lambda gt: gt["video_path"])
+        print_rank_0(f"Found {len(ground_truth)} videos to process.")
+
+        if num_partitions > 0:
+            start_idx, end_idx = _get_partition_bounds(
+                len(ground_truth), num_samples_per_partition, num_partitions, partition_id
+            )
+            ground_truth = ground_truth[start_idx:end_idx]
+
+        self._ground_truth = ground_truth
+        self._img_h = img_h
+        self._img_w = img_w
+        self._use_tiling = False
+        self._max_num_tiles = max_num_tiles
+        self._use_thumbnail = use_thumbnail
+        self._num_frames = num_frames
+        self._transform_img = ImageTransform(img_h, vision_model_type)
+
+    def __len__(self):
+        return len(self._ground_truth)
+
+    def __getitem__(self, idx):
+        from torchvision.io import read_video
+
+        gt = self._ground_truth[idx]
+
+        video, _, _ = read_video(gt["video_path"], start_pts=0, end_pts=None, pts_unit='sec')
+        video = video.numpy()
+        selected_frames = torch.linspace(0, video.shape[0] - 1, self._num_frames).long()
+        video_frames = video[selected_frames]
+        if self._num_frames == 1:
+            video_frames = video_frames[None]
+
+        imgs = []
+        for img in video_frames:
+            from torchvision.transforms import ToPILImage
+            to_pil = ToPILImage()
+            img = to_pil(img)
+            imgs += self._transform_img(
+                img, self._img_h, self._img_w, self._use_tiling, self._max_num_tiles,
+                self._use_thumbnail, augment=False,
+            )
+
+        for question in gt["questions"]:
+            # Very hacky, but we essentially re-create gt holding only the
+            # question of interest. This is the make this generation script
+            # compatible with the Video MME evaluation script.
+            question_dict = {
+                "video_id": gt["video_id"],
+                "duration_category": gt["duration_category"],
+                "video_category": gt["video_category"],
+                "video_subcategory": gt["video_subcategory"],
+                "url": gt["url"],
+                "questions": [question],
+            }
+
+        num_tiles = torch.tensor([len(imgs)], dtype=torch.int)
+
+        answer = ""
+        metadata = ""
+
+        return (
+            torch.stack(imgs),
+            num_tiles,
+            question["question_id"],
+            question_dict,
+            answer,
+            metadata,
+        )
+
+
+class OCRBenchDataset(torch.utils.data.Dataset):
+    """OCRBench evaluation dataset."""
+
+    def __init__(
+        self,
+        input_image_path,
+        gt_path,
+        num_samples_per_partition,
+        num_partitions,
+        partition_id,
+        img_h,
+        img_w,
+        use_tiling,
+        max_num_tiles,
+        use_thumbnail,
+        vision_model_type,
+    ):
+        gt = json.load(open(gt_path, encoding='utf-8'))
+
+        if num_partitions > 0:
+            start_idx, end_idx = _get_partition_bounds(
+                len(gt), num_samples_per_partition, num_partitions, partition_id
+            )
+            gt = gt[start_idx:end_idx]
+
+        self._input_image_path = input_image_path
+        self._gt = gt
+        self._img_h = img_h
+        self._img_w = img_w
+        self._use_tiling = use_tiling
+        self._max_num_tiles = max_num_tiles
+        self._use_thumbnail = use_thumbnail
+        self._transform_img = ImageTransform(img_h, vision_model_type)
+
+    def __len__(self):
+        return len(self._gt)
+
+    def __getitem__(self, idx):
+        img_path = os.path.join(self._input_image_path, self._gt[idx]['image_path'])
+
+        img = Image.open(img_path)
+        imgs = self._transform_img(
+            img,
+            self._img_h,
+            self._img_w,
+            self._use_tiling,
+            self._max_num_tiles,
+            self._use_thumbnail,
+            augment=False,
+        )
+
+        tile_count = torch.tensor([len(imgs)], dtype=torch.int)
+
+        metadata = {
+            "dataset_name": self._gt[idx]["dataset_name"],
+            "data_type": self._gt[idx]["type"],
+        }
+
+        return (
+            torch.stack(imgs),
+            tile_count,
+            idx,
+            self._gt[idx]["question"],
+            self._gt[idx]["answers"],
+            metadata,
+        )
+
+
+class MathVistaDataset(torch.utils.data.Dataset):
+    """MathVista evaluation dataset."""
+
+    def __init__(
+        self,
+        input_image_path,
+        num_samples_per_partition,
+        num_partitions,
+        partition_id,
+        img_h,
+        img_w,
+        use_tiling,
+        max_num_tiles,
+        use_thumbnail,
+        vision_model_type,
+    ):
+        import datasets
+
+        hf_datasets_cache = os.environ["HF_DATASETS_CACHE"]
+        assert hf_datasets_cache != "", "Please set the environment variable HF_DATASETS_CACHE."
+
+        if os.path.exists(input_image_path):
+            dataset = datasets.load_dataset(
+                input_image_path, cache_dir=hf_datasets_cache, verification_mode="no_checks", split="train"
+            )
+        else:
+            dataset = datasets.load_dataset(
+                "AI4Math/MathVista", split="testmini", cache_dir=hf_datasets_cache
+            )
+
+        if num_partitions > 0:
+            start_idx, end_idx = _get_partition_bounds(
+                len(dataset), num_samples_per_partition, num_partitions, partition_id
+            )
+            dataset = dataset[start_idx:end_idx]
+
+        self._dataset = dataset
+        self._img_h = img_h
+        self._img_w = img_w
+        self._use_tiling = use_tiling
+        self._max_num_tiles = max_num_tiles
+        self._use_thumbnail = use_thumbnail
+        self._transform_img = ImageTransform(img_h, vision_model_type)
+
+    def __len__(self):
+        return len(self._dataset["pid"])
+
+    def __getitem__(self, idx):
+        # Already a PIL object.
+        img = self._dataset['decoded_image'][idx]
+
+        imgs = self._transform_img(
+            img,
+            self._img_h,
+            self._img_w,
+            self._use_tiling,
+            self._max_num_tiles,
+            self._use_thumbnail,
+            augment=False,
+        )
+
+        tile_count = torch.tensor([len(imgs)], dtype=torch.int)
+
+        question_id = self._dataset["pid"][idx]
+        question = self._dataset["question"][idx]
+        question_type = self._dataset["question_type"][idx]  # free_form or multi_choice
+        query = self._dataset["query"][idx]
+        choices = self._dataset["choices"][idx]
+        answer = self._dataset["answer"][idx]
+
+        if question_type == 'multi_choice':
+            start_chr = 'A'
+            choices_str = ''
+            index2ans = {}
+            all_choices = []
+            for choice in choices:
+                all_choices.append(start_chr)
+                index2ans[start_chr] = choice
+                choices_str += f"{start_chr}. {choice}\n"
+                start_chr = chr(ord(start_chr) + 1)
+
+            question = question + '\n' + choices_str
+            question = question + "Answer with the option's letter from the given choices directly."
+            answer = chr(ord('A') + choices.index(answer))
+        else:
+            question = query.replace("Hint: ", "")
+            index2ans = {}
+            all_choices = []
+
+        metadata = {
+            "question_type": question_type,
+            "index2ans": index2ans,
+            "all_choices": all_choices,
+        }
+
+        return torch.stack(imgs), tile_count, question_id, question, answer, metadata
+
+
+class AI2DDataset(torch.utils.data.Dataset):
+    """AI2D evaluation dataset."""
+
+    def __init__(
+        self,
+        input_image_path,
+        gt_path,
+        num_samples_per_partition,
+        num_partitions,
+        partition_id,
+        img_h,
+        img_w,
+        use_tiling,
+        max_num_tiles,
+        use_thumbnail,
+        vision_model_type,
+    ):
+        with open(gt_path, 'r') as f:
+            jsonl = list(f)
+
+        gt = [json.loads(json_str) for json_str in jsonl]
+
+        if num_partitions > 0:
+            start_idx, end_idx = _get_partition_bounds(
+                len(gt), num_samples_per_partition, num_partitions, partition_id
+            )
+            gt = gt[start_idx:end_idx]
+
+        self._gt = gt
+        self._input_image_path = input_image_path
+        self._img_h = img_h
+        self._img_w = img_w
+        self._use_tiling = use_tiling
+        self._max_num_tiles = max_num_tiles
+        self._use_thumbnail = use_thumbnail
+        self._transform_img = ImageTransform(img_h, vision_model_type)
+
+    def __len__(self):
+        return len(self._gt)
+
+    def __getitem__(self, idx):
+        img_path = os.path.join(self._input_image_path, self._gt[idx]['image'].split("/")[-1])
+
+        img = Image.open(img_path)
+        imgs = self._transform_img(
+            img,
+            self._img_h,
+            self._img_w,
+            self._use_tiling,
+            self._max_num_tiles,
+            self._use_thumbnail,
+            augment=False,
+        )
+
+        tile_count = torch.tensor([len(imgs)], dtype=torch.int)
+
+        metadata = ""  # Not used.
+
+        return (
+            torch.stack(imgs),
+            tile_count,
+            self._gt[idx]["question_id"],
+            self._gt[idx]["question"],
+            self._gt[idx]["answer"],
+            metadata,
+        )
+
+
+class RDTableBenchDataset(torch.utils.data.Dataset):
+    def __init__(
+        self,
+        input_image_path,
+        gt_path,
+        num_samples_per_partition,
+        num_partitions,
+        partition_id,
+        img_h,
+        img_w,
+        use_tiling,
+        max_num_tiles,
+        use_thumbnail,
+        vision_model_type,
+    ):
+        gt_paths = sorted(glob.glob(os.path.join(gt_path, "*.html")))
+        gt = []
+        for gt_path in gt_paths:
+            img_path = os.path.join(input_image_path, os.path.basename(gt_path).replace(".html", ".jpg"))
+            with open(gt_path) as f:
+                html = f.read()
+            gt.append({
+                "answer": html,
+                "image": img_path,
+            })
+
+        if num_partitions > 0:
+            start_idx, end_idx = _get_partition_bounds(
+                len(gt), num_samples_per_partition, num_partitions, partition_id
+            )
+            gt = gt[start_idx:end_idx]
+
+        self._input_image_path = input_image_path
+        self._gt = gt
+        self._img_h = img_h
+        self._img_w = img_w
+        self._use_tiling = use_tiling
+        self._max_num_tiles = max_num_tiles
+        self._use_thumbnail = use_thumbnail
+        self._transform_img = ImageTransform(img_h, vision_model_type)
+
+    def __len__(self):
+        return len(self._gt)
+
+    def __getitem__(self, idx):
+        img_path = os.path.join(self._input_image_path, self._gt[idx]['image'])
+
+        img = Image.open(img_path)
+        imgs = self._transform_img(
+            img,
+            self._img_h,
+            self._img_w,
+            self._use_tiling,
+            self._max_num_tiles,
+            self._use_thumbnail,
+            augment=False,
+        )
+
+        tile_count = torch.tensor([len(imgs)], dtype=torch.int)
+
+        metadata = ""
+
+        prompt = (
+            "Convert the image to an HTML table. The output should begin with <table> and end with </table>. "
+            "Specify rowspan and colspan attributes when they are greater than 1. Do not specify any other attributes. "
+            "Only use table related HTML tags, no additional formatting is required."
+        )
+
+        return (
+            torch.stack(imgs),
+            tile_count,
+            idx,
+            prompt,
+            self._gt[idx]["answer"],
+            metadata,
+        )
+
+
+class RealworldQADataset(torch.utils.data.Dataset):
+    def __init__(
+        self,
+        input_image_path,
+        gt_path,
+        num_samples_per_partition,
+        num_partitions,
+        partition_id,
+        img_h,
+        img_w,
+        use_tiling,
+        max_num_tiles,
+        use_thumbnail,
+        vision_model_type,
+    ):
+        gt = json.load(open(gt_path, encoding='utf-8'))
+
+
+        if num_partitions > 0:
+            start_idx, end_idx = _get_partition_bounds(
+                len(gt), num_samples_per_partition, num_partitions, partition_id
+            )
+            gt = gt[start_idx:end_idx]
+
+        self._gt = gt
+        self._input_image_path = input_image_path
+        self._img_h = img_h
+        self._img_w = img_w
+        self._use_tiling = use_tiling
+        self._max_num_tiles = max_num_tiles
+        self._use_thumbnail = use_thumbnail
+        self._transform_img = ImageTransform(img_h, vision_model_type)
+
+
+    def __len__(self):
+        return len(self._gt)
+
+    def __getitem__(self, idx):
+        img_path = os.path.join(self._input_image_path, self._gt[idx]['image'])
+        img = Image.open(img_path)
+        imgs = self._transform_img(
+            img,
+            self._img_h,
+            self._img_w,
+            self._use_tiling,
+            self._max_num_tiles,
+            self._use_thumbnail,
+            augment=False,
+        )
+
+        question_id = int(self._gt[idx]['image'].replace(".webp", ""))
+        question = self._gt[idx]["question"]
+
+        if self._gt[idx]['question_type'] == "multi-choice":
+            choices = self._gt[idx]["choices"]
+            start_chr = 'A'
+            choices_str = ''
+            index2ans = {}
+            all_choices = []
+            for choice in choices:
+                all_choices.append(start_chr)
+                index2ans[start_chr] = choice
+                choices_str += f"{start_chr}. {choice}\n"
+                start_chr = chr(ord(start_chr) + 1)
+
+            question = question + '\n' + choices_str
+            question = question + "Answer with the option's letter from the given choices directly."
+            answer = chr(ord('A') + self._gt[idx]['correct_choice_index'])
+        else:
+            question = question + "\nAnswer the question using a single word or phrase."
+            answer = self._gt[idx]['answer']
+
+        tile_count = torch.tensor([len(imgs)], dtype=torch.int)
+
+        metadata = ""  # Not used.
+
+        return (
+            torch.stack(imgs),
+            tile_count,
+            question_id,
+            question,
+            [answer],
+            metadata,
+        )
+
+
+
+class MotionBenchDataset(torch.utils.data.Dataset):
+    def __init__(
+        self,
+        input_image_path,
+        gt_path,
+        num_samples_per_partition,
+        num_partitions,
+        partition_id,
+        img_h,
+        img_w,
+        use_tiling,
+        max_num_tiles,
+        use_thumbnail,
+        num_frames,
+        vision_model_type,
+        split
+    ):
+
+        with open(gt_path) as f:
+            ground_truth_original = [json.loads(line) for line in f]
+
+
+        ground_truth = []
+        for gt in ground_truth_original:
+
+            # video path handling
+            video_path = gt['video_path']
+            if ".mp4" not in video_path:
+                video_path = f"{video_path}.mp4"
+
+            video_path = os.path.join(input_image_path, video_path)
+            if not os.path.exists(video_path):
+                continue
+            gt["video_path"] = video_path
+
+            ground_truth.append(gt)
+
+        ground_truth = sorted(ground_truth, key=lambda gt: gt["video_path"])
+        print_rank_0(f"Found {len(ground_truth)} videos to process.")
+
+        if num_partitions > 0:
+            start_idx, end_idx = _get_partition_bounds(
+                len(ground_truth), num_samples_per_partition, num_partitions, partition_id
+            )
+            ground_truth = ground_truth[start_idx:end_idx]
+
+        self._ground_truth = ground_truth
+        self._img_h = img_h
+        self._img_w = img_w
+        self._use_tiling = False
+        self._max_num_tiles = max_num_tiles
+        self._use_thumbnail = use_thumbnail
+        self._num_frames = num_frames
+        self._transform_img = ImageTransform(img_h, vision_model_type)
+
+    def __len__(self):
+        return len(self._ground_truth)
+
+    def __getitem__(self, idx):
+        gt = self._ground_truth[idx]
+
+        from torchvision.io.video import read_video
+        video, _, _ = read_video(gt["video_path"], start_pts=0, end_pts=None, pts_unit='sec')
+        video = video.permute((0, 3, 1, 2))
+
+        selected_frames = torch.linspace(0, video.shape[0] - 1, min(self._num_frames, video.shape[0])).long()
+        video_frames = video[selected_frames]
+
+        if self._num_frames == 1:
+            video_frames = video_frames[None]
+        imgs = []
+        for img in video_frames:
+            from torchvision.transforms import ToPILImage
+            to_pil = ToPILImage()
+            img = to_pil(img)
+            imgs += self._transform_img(
+                img,
+                self._img_h,
+                self._img_w,
+                self._use_tiling,
+                self._max_num_tiles,
+                self._use_thumbnail,
+                augment=False,
+            )
+
+        num_tiles = torch.tensor([len(imgs)], dtype=torch.int)
+
+        q_id = gt['qa'][0]['uid']
+        question = gt['qa'][0]['question']
+        answer = gt['qa'][0]['answer']
+
+        metadata = ""
+        return (
+            torch.stack(imgs),
+            num_tiles,
+            q_id,
+            question,
+            answer,
+            metadata,
+        )
+
+# The following class is adapted from
+# https://github.com/PhysGame/PhysGame/blob/main/physvlm/test/PhysGame_bench/utils.py#L27
+# which is licensed under the MIT license. More details on the license can be
+# found at https://github.com/PhysGame/PhysGame/tree/main?tab=Apache-2.0-1-ov-file#readme
+class PhysGameBenchDataset(torch.utils.data.Dataset):
+    def __init__(
+        self,
+        input_image_path,
+        gt_path,
+        num_samples_per_partition,
+        num_partitions,
+        partition_id,
+        img_h,
+        img_w,
+        use_tiling,
+        max_num_tiles,
+        use_thumbnail,
+        num_frames,
+        vision_model_type,
+        split
+    ):
+
+        ground_truth_original = json.load(open(gt_path, encoding='utf-8'))
+
+        ground_truth = []
+        for gt in ground_truth_original:
+
+            video_path = os.path.join(input_image_path, gt['question_id']) + ".mp4"
+            if not os.path.exists(video_path):
+                continue
+            gt["video_path"] = video_path
+            ground_truth.append(gt)
+
+        ground_truth = sorted(ground_truth, key=lambda gt: gt["video_path"])
+        print_rank_0(f"Found {len(ground_truth)} videos to process.")
+
+        if num_partitions > 0:
+            start_idx, end_idx = _get_partition_bounds(
+                len(ground_truth), num_samples_per_partition, num_partitions, partition_id
+            )
+            ground_truth = ground_truth[start_idx:end_idx]
+
+        self._ground_truth = ground_truth
+        self._img_h = img_h
+        self._img_w = img_w
+        self._use_tiling = False
+        self._max_num_tiles = max_num_tiles
+        self._use_thumbnail = use_thumbnail
+        self._num_frames = num_frames
+        self._transform_img = ImageTransform(img_h, vision_model_type)
+
+    def __len__(self):
+        return len(self._ground_truth)
+
+    def _qa_template(self, data):
+        question = f"Question: {data['question']}\n"
+        question += "Options:\n"
+        answer = data['answer']
+        for ch, c in data['options'].items():
+            question += f"({ch}) {c}\n"
+        question = question.rstrip()
+        return question, answer
+
+    def __getitem__(self, idx):
+        gt = self._ground_truth[idx]
+
+        from torchvision.io.video import read_video
+        video, _, _ = read_video(gt["video_path"], start_pts=0, end_pts=None, pts_unit='sec')
+        video = video.permute((0, 3, 1, 2))
+
+        selected_frames = torch.linspace(0, video.shape[0] - 1, min(self._num_frames, video.shape[0])).long()
+        video_frames = video[selected_frames]
+
+        if self._num_frames == 1:
+            video_frames = video_frames[None]
+        imgs = []
+        for img in video_frames:
+            from torchvision.transforms import ToPILImage
+            to_pil = ToPILImage()
+            img = to_pil(img)
+            imgs += self._transform_img(
+                img,
+                self._img_h,
+                self._img_w,
+                self._use_tiling,
+                self._max_num_tiles,
+                self._use_thumbnail,
+                augment=False,
+            )
+
+        num_tiles = torch.tensor([len(imgs)], dtype=torch.int)
+
+        q_id = gt['question_id']
+        question, answer = self._qa_template(gt)
+
+        metadata = {
+            'class': gt['class_anno'],
+            'subclass': gt['subclass_anno']
+        }
+
+        return (
+            torch.stack(imgs),
+            num_tiles,
+            q_id,
+            question,
+            answer,
+            metadata,
+        )
+
+
+# The following class is adapted from
+# https://github.com/OpenGVLab/Ask-Anything/blob/main/video_chat2/mvbench.ipynb
+# which is licensed under the MIT license. More details on the license can be
+# found at https://github.com/OpenGVLab/Ask-Anything/tree/main?tab=MIT-1-ov-file#readme
+class MVBenchDataset(torch.utils.data.Dataset):
+    def __init__(
+        self,
+        input_image_path,
+        gt_path,
+        num_samples_per_partition,
+        num_partitions,
+        partition_id,
+        img_h,
+        img_w,
+        use_tiling,
+        max_num_tiles,
+        use_thumbnail,
+        num_frames,
+        vision_model_type,
+        split
+    ):
+
+        data_list = {
+            "Action Sequence": ("action_sequence.json", f"{input_image_path}/star/Charades_v1_480/", "video", True), # has start & end
+            "Action Prediction": ("action_prediction.json", f"{input_image_path}/star/Charades_v1_480/", "video", True), # has start & end
+            "Action Antonym": ("action_antonym.json", f"{input_image_path}/ssv2_video/", "video", False),
+            "Fine-grained Action": ("fine_grained_action.json", f"{input_image_path}/Moments_in_Time_Raw/videos/", "video", False),
+            "Unexpected Action": ("unexpected_action.json", f"{input_image_path}/FunQA_test/test/", "video", False),
+            "Object Existence": ("object_existence.json", f"{input_image_path}/clevrer/video_validation/", "video", False),
+            "Object Interaction": ("object_interaction.json", f"{input_image_path}/star/Charades_v1_480/", "video", True), # has start & end
+            "Object Shuffle": ("object_shuffle.json", f"{input_image_path}/perception/videos/", "video", False),
+            "Moving Direction": ("moving_direction.json", f"{input_image_path}/clevrer/video_validation/", "video", False),
+            "Action Localization": ("action_localization.json", f"{input_image_path}/sta/sta_video/", "video", True),  # has start & end
+            "Scene Transition": ("scene_transition.json", f"{input_image_path}/scene_qa/video/", "video", False),
+            "Action Count": ("action_count.json", f"{input_image_path}/perception/videos/", "video", False),
+            "Moving Count": ("moving_count.json", f"{input_image_path}/clevrer/video_validation/", "video", False),
+            "Moving Attribute": ("moving_attribute.json", f"{input_image_path}/clevrer/video_validation/", "video", False),
+            "State Change": ("state_change.json", f"{input_image_path}/perception/videos/", "video", False),
+            "Fine-grained Pose": ("fine_grained_pose.json", f"{input_image_path}/nturgbd/", "video", False),
+            "Character Order": ("character_order.json", f"{input_image_path}/perception/videos/", "video", False),
+            "Egocentric Navigation": ("egocentric_navigation.json", f"{input_image_path}/vlnqa/", "video", False),
+            "Episodic Reasoning": ("episodic_reasoning.json", f"{input_image_path}/tvqa/frames_fps3_hq/", "frame", True),  # has start & end, read frame
+            "Counterfactual Inference": ("counterfactual_inference.json", f"{input_image_path}/clevrer/video_validation/", "video", False)
+        }
+
+        ground_truth = []
+        for k, v in data_list.items():
+            with open(os.path.join(gt_path, v[0]), 'r') as f:
+                json_data = json.load(f)
+            for data_id, data in enumerate(json_data):
+                ground_truth.append({
+                    'task_type': k,
+                    'prefix': v[1],
+                    'data_type': v[2],
+                    'bound': v[3],
+                    'data': data,
+                    'question_id': f"{k}-{data_id}"
+                })
+
+        print("total ground truth ==> ", len(ground_truth))
+        self.decord_method = {
+            'video': self.read_video_ours,
+            'frame': self.read_frame,
+        }
+
+        if num_partitions > 0:
+            start_idx, end_idx = _get_partition_bounds(
+                len(ground_truth), num_samples_per_partition, num_partitions, partition_id
+            )
+            ground_truth = ground_truth[start_idx:end_idx]
+
+            print("Partitioned ==> ", {start_idx}, {end_idx}, len(ground_truth))
+
+        self._ground_truth = ground_truth
+        self._img_h = img_h
+        self._img_w = img_w
+        self._use_tiling = False
+        self._max_num_tiles = max_num_tiles
+        self._use_thumbnail = use_thumbnail
+        self._num_frames = num_frames
+        self._transform_img = ImageTransform(img_h, vision_model_type)
+
+    def __len__(self):
+        return len(self._ground_truth)
+
+    def get_index(self, bound, fps, max_frame, first_idx=0):
+        if bound:
+            start, end = bound[0], bound[1]
+        else:
+            start, end = -100000, 100000
+        start_idx = max(first_idx, round(start * fps))
+        end_idx = min(round(end * fps), max_frame)
+        seg_size = float(end_idx - start_idx) / self._num_frames
+        frame_indices = np.array([
+            int(start_idx + (seg_size / 2) + np.round(seg_size * idx))
+            for idx in range(self._num_frames)
+        ])
+        return frame_indices
+
+    def qa_template(self, data):
+        question = f"Question: {data['question']}\n"
+        question += "Options:\n"
+        answer = data['answer']
+        answer_idx = -1
+        for idx, c in enumerate(data['candidates']):
+            question += f"({chr(ord('A') + idx)}) {c}\n"
+            if c == answer:
+                answer_idx = idx
+        question = question.rstrip()
+        answer = f"({chr(ord('A') + answer_idx)}) {answer}"
+        return question, answer
+
+
+    def read_frame(self, video_path, bound=None, fps=2):
+        max_frame = len(os.listdir(video_path))
+        images_group = list()
+        frame_indices = self.get_index(bound, fps, max_frame, first_idx=1) # frame_idx starts from 1
+        for frame_index in frame_indices:
+            img = Image.open(os.path.join(video_path, f"{frame_index:05d}.jpg"))
+            images_group.append(img)
+        return images_group
+
+    def read_video_ours(self, video_path, bound=None):
+        from torchvision.io.video import read_video
+        video, _, v_meta_info = read_video(video_path, start_pts=0, end_pts=None, pts_unit='sec')
+
+        video = video.permute((0, 3, 1, 2))
+        fps = float(v_meta_info['video_fps'])
+        max_frame = len(video) - 1
+
+        selected_frames_indices = self.get_index(bound, fps, max_frame, first_idx=0)
+
+        video_frames = video[selected_frames_indices]
+
+        return video_frames
+
+    def __getitem__(self, idx):
+
+        data = self._ground_truth[idx]
+        bound = None
+        if data['bound']:
+            bound = (
+                data['data']['start'],
+                data['data']['end'],
+            )
+        video_path = os.path.join(data['prefix'], data['data']['video'])
+
+        video_decode_func = self.decord_method[data['data_type']]
+
+        video_frames = video_decode_func(video_path, bound)
+
+        imgs = []
+        for img in video_frames:
+            from torchvision.transforms import ToPILImage
+
+            if data['data_type'] == 'video':
+                to_pil = ToPILImage()
+                img = to_pil(img)
+            imgs += self._transform_img(
+                img, self._img_h, self._img_w, self._use_tiling, self._max_num_tiles,
+                self._use_thumbnail, augment=False
+            )
+
+        num_tiles = torch.tensor([len(imgs)], dtype=torch.int)
+
+        q_id = data['question_id']
+        metadata = {'task_type': data['task_type']}
+        question, answer = self.qa_template(data['data'])
+
+        return (
+            torch.stack(imgs),
+            num_tiles,
+            q_id,
+            question,
+            answer,
+            metadata,
+        )
+
+
+class ExampleInferenceDataset(torch.utils.data.Dataset):
+    def __init__(
+        self,
+        img_h,
+        img_w,
+        use_tiling,
+        max_num_tiles,
+        use_thumbnail,
+        vision_model_type,
+    ):
+        # Define your own inference samples here. The following is an example.
+        samples = [
+            # Use <image> token to indicate the image position.
+            {"image_paths": ["examples/multimodal/assets/pretrain_curves.png"], "question": "<image>\nWhat is the curve?"},
+            # Optional: if you have an answer for the question.
+            {"image_paths": ["examples/multimodal/assets/pretrain_curves.png"], "question": "What is the curve?<image>", "answer": "It's a loss function curve."},
+            # If you have multiple images for the question, then use <image> token to indicate the image positions.
+            {"image_paths": ["examples/multimodal/assets/pretrain_curves.png", "examples/multimodal/assets/pretrain_curves.png"], "question": "<image>What is the curve?<image>"},
+            # Text only sample.
+            {"question": "Who is Jensen Huang?"},
+        ]
+
+        self._samples = samples
+        self._img_h = img_h
+        self._img_w = img_w
+        self._use_tiling = use_tiling
+        self._max_num_tiles = max_num_tiles
+        self._use_thumbnail = use_thumbnail
+        self._transform_img = ImageTransform(img_h, vision_model_type)
+
+    def __len__(self):
+        return len(self._samples)
+
+    def __getitem__(self, idx):
+        sample = self._samples[idx]
+
+        sample_imgs = []
+        sample_tile_count = []
+        for image_path in sample.get("image_paths", []):
+            img = Image.open(image_path)
+            imgs = self._transform_img(
+                img,
+                self._img_h,
+                self._img_w,
+                self._use_tiling,
+                self._max_num_tiles,
+                self._use_thumbnail,
+                augment=False,
+            )
+
+            sample_imgs.extend(imgs)
+            sample_tile_count.append(len(imgs))
+
+        sample_id = idx
+        metadata = ""  # Not used.
+
+        return (
+            torch.stack(sample_imgs) if len(sample_imgs) > 0 else torch.tensor([]),
+            torch.tensor(sample_tile_count, dtype=torch.int),
+            sample_id,
+            sample["question"],
+            sample.get("answer", ""),
+            metadata,
+        )
+
+
+def get_evaluation_dataset(
+    task,
+    input_image_path,
+    gt_path,
+    img_h,
+    img_w,
+    use_tiling,
+    max_num_tiles,
+    use_thumbnail,
+    num_samples_per_partition,
+    num_partitions,
+    partition_id,
+    num_frames,
+    vision_model_type,
+    split="validation",
+):
+    """Get an evaluation dataset."""
+    if task == "TextVQA":
+        keys = {
+            "image_id": "image_id",
+            "sample_id": "question_id",
+            "question": "question",
+            "answer": "answers",
+        }
+
+        dataset = VQADataset(
+            input_image_path,
+            gt_path,
+            num_samples_per_partition,
+            num_partitions,
+            partition_id,
+            keys,
+            img_h,
+            img_w,
+            use_tiling,
+            max_num_tiles,
+            use_thumbnail,
+            vision_model_type,
+        )
+    elif task == "VQAv2":
+        keys = {
+            "image_id": "image",
+            "sample_id": "question_id",
+            "question": "question",
+            "answer": "answer",
+        }
+
+        dataset = VQADataset(
+            input_image_path,
+            gt_path,
+            num_samples_per_partition,
+            num_partitions,
+            partition_id,
+            keys,
+            img_h,
+            img_w,
+            use_tiling,
+            max_num_tiles,
+            use_thumbnail,
+            vision_model_type,
+        )
+    elif task == "ChartQA":
+        keys = {"image_id": "imgname", "question": "query", "answer": "label"}
+
+        dataset = VQADataset(
+            input_image_path,
+            gt_path,
+            num_samples_per_partition,
+            num_partitions,
+            partition_id,
+            keys,
+            img_h,
+            img_w,
+            use_tiling,
+            max_num_tiles,
+            use_thumbnail,
+            vision_model_type,
+        )
+    elif task == "captioning":
+        dataset = CaptioningDataset(
+            input_image_path,
+            gt_path,
+            num_samples_per_partition,
+            num_partitions,
+            partition_id,
+            img_h,
+            img_w,
+            use_tiling,
+            max_num_tiles,
+            use_thumbnail,
+            vision_model_type,
+        )
+    elif task == 'MMMU':
+        # Note:
+        # - prompt_style="single_image" uses only one image like in the MMMU repo example.
+        # - prompt_style="multi_image" uses multiple input images.
+        # - prompt_style="vlmevalkit" is similar to https://github.com/open-compass/VLMEvalKit/blob/5d3cebcf18ef4bfbadc3bd3ef80bdc7aad2c6557/vlmeval/vlm/internvl_chat.py#L499
+        dataset = MMMUDataset(
+            input_image_path,
+            num_samples_per_partition,
+            num_partitions,
+            partition_id,
+            img_h,
+            img_w,
+            use_tiling,
+            max_num_tiles,
+            use_thumbnail,
+            prompt_style="single_image",
+            vision_model_type=vision_model_type,
+            split=split,
+        )
+    elif task == 'RealworldQA':
+        dataset = RealworldQADataset(
+            input_image_path,
+            gt_path,
+            num_samples_per_partition,
+            num_partitions,
+            partition_id,
+            img_h,
+            img_w,
+            use_tiling,
+            max_num_tiles,
+            use_thumbnail,
+            vision_model_type=vision_model_type,
+        )
+    elif task in ["OCRBench", "OCRBench_v2"]:
+        dataset = OCRBenchDataset(
+            input_image_path,
+            gt_path,
+            num_samples_per_partition,
+            num_partitions,
+            partition_id,
+            img_h,
+            img_w,
+            use_tiling,
+            max_num_tiles,
+            use_thumbnail,
+            vision_model_type,
+        )
+    elif task == "MathVista":
+        dataset = MathVistaDataset(
+            input_image_path,
+            num_samples_per_partition,
+            num_partitions,
+            partition_id,
+            img_h,
+            img_w,
+            use_tiling,
+            max_num_tiles,
+            use_thumbnail,
+            vision_model_type,
+        )
+    elif task == "AI2D":
+        dataset = AI2DDataset(
+            input_image_path,
+            gt_path,
+            num_samples_per_partition,
+            num_partitions,
+            partition_id,
+            img_h,
+            img_w,
+            use_tiling,
+            max_num_tiles,
+            use_thumbnail,
+            vision_model_type=vision_model_type,
+        )
+    elif task == "SPDocVQA":
+        keys = {"sample_id": "questionId", "image_id": "image", "question": "question", "answer": "answers"}
+
+        dataset = VQADataset(
+            input_image_path,
+            gt_path,
+            num_samples_per_partition,
+            num_partitions,
+            partition_id,
+            keys,
+            img_h,
+            img_w,
+            use_tiling,
+            max_num_tiles,
+            use_thumbnail,
+            vision_model_type,
+        )
+    elif task == "InfoVQA":
+        keys = {"sample_id": "questionId", "image_id": "image_local_name", "question": "question", "answer": "answers"}
+
+        dataset = VQADataset(
+            input_image_path,
+            gt_path,
+            num_samples_per_partition,
+            num_partitions,
+            partition_id,
+            keys,
+            img_h,
+            img_w,
+            use_tiling,
+            max_num_tiles,
+            use_thumbnail,
+            vision_model_type,
+        )
+    elif task == "RD_TableBench":
+        dataset = RDTableBenchDataset(
+            input_image_path,
+            gt_path,
+            num_samples_per_partition,
+            num_partitions,
+            partition_id,
+            img_h,
+            img_w,
+            use_tiling,
+            max_num_tiles,
+            use_thumbnail,
+            vision_model_type,
+        )
+    ### video QA
+    elif task == "VideoMME":
+        dataset = VideoMMEDataset(
+            input_image_path,
+            gt_path,
+            num_samples_per_partition,
+            num_partitions,
+            partition_id,
+            img_h,
+            img_w,
+            use_tiling,
+            max_num_tiles,
+            use_thumbnail,
+            num_frames,
+            vision_model_type,
+        )
+    elif task == "MotionBench":
+        dataset = MotionBenchDataset(
+            input_image_path,
+            gt_path,
+            num_samples_per_partition,
+            num_partitions,
+            partition_id,
+            img_h,
+            img_w,
+            use_tiling,
+            max_num_tiles,
+            use_thumbnail,
+            num_frames,
+            vision_model_type,
+            split=split
+        )
+    elif task == "PhysGameBench":
+        dataset = PhysGameBenchDataset(
+            input_image_path,
+            gt_path,
+            num_samples_per_partition,
+            num_partitions,
+            partition_id,
+            img_h,
+            img_w,
+            use_tiling,
+            max_num_tiles,
+            use_thumbnail,
+            num_frames,
+            vision_model_type,
+            split=split
+        )
+    elif task == "MVBench":
+        dataset = MVBenchDataset(
+            input_image_path,
+            gt_path,
+            num_samples_per_partition,
+            num_partitions,
+            partition_id,
+            img_h,
+            img_w,
+            use_tiling,
+            max_num_tiles,
+            use_thumbnail,
+            num_frames,
+            vision_model_type,
+            split=split
+        )
+    elif task == "inference":
+        dataset = ExampleInferenceDataset(
+            img_h,
+            img_w,
+            use_tiling,
+            max_num_tiles,
+            use_thumbnail,
+            vision_model_type,
+        )
+    else:
+        raise NotImplementedError(f"unsupported task {task}")
+
+    return dataset
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/image_processing.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/image_processing.py
new file mode 100644
index 0000000000000000000000000000000000000000..d87cfa385838a2535218c1b082baed218bb52c6c
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/image_processing.py
@@ -0,0 +1,168 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved. Except portions as noted which are Copyright (c) 2023 OpenGVLab and licensed under the MIT license found in LICENSE.
+from torchvision import transforms as T
+from torchvision.transforms import Compose
+from torchvision.transforms.functional import InterpolationMode
+
+
+IMAGENET_PIXEL_MEAN = [0.485, 0.456, 0.406]
+IMAGENET_PIXEL_STD = [0.229, 0.224, 0.225]
+SIGLIP_PIXEL_MEAN = [0.5, 0.5, 0.5]
+SIGLIP_PIXEL_STD = [0.5, 0.5, 0.5]
+CLIP_PIXEL_MEAN = [0.48145466, 0.4578275, 0.40821073]
+CLIP_PIXEL_STD = [0.26862954, 0.26130258, 0.27577711]
+RADIO_G_PIXEL_MEAN = [0.4850, 0.4560, 0.4060]
+RADIO_G_PIXEL_STD = [0.2230, 0.2240, 0.2250]
+
+
+pixel_statistics = {
+    "clip": (CLIP_PIXEL_MEAN, CLIP_PIXEL_STD),
+    "siglip": (SIGLIP_PIXEL_MEAN, SIGLIP_PIXEL_STD),
+    "internvit": (IMAGENET_PIXEL_MEAN, IMAGENET_PIXEL_STD),
+    "radio": (CLIP_PIXEL_MEAN, CLIP_PIXEL_STD),
+    "radio-g": (RADIO_G_PIXEL_MEAN, RADIO_G_PIXEL_STD),
+    "cradio-g": (CLIP_PIXEL_MEAN, CLIP_PIXEL_STD),
+    "internvit300M": (IMAGENET_PIXEL_MEAN, IMAGENET_PIXEL_STD),
+    "huggingface": (SIGLIP_PIXEL_MEAN, SIGLIP_PIXEL_STD),
+}
+
+
+# From https://github.com/OpenGVLab/InternVL/blob/c62fa4f7c850165d7386bdc48ac6bc5a6fab0864/internvl_chat/internvl/train/dataset.py#L685
+# Copyright (c) 2023 OpenGVLab.
+def find_closest_aspect_ratio(aspect_ratio, target_ratios, width, height, image_size):
+    best_ratio_diff = float('inf')
+    best_ratio = (1, 1)
+    area = width * height
+    for ratio in target_ratios:
+        target_aspect_ratio = ratio[0] / ratio[1]
+        ratio_diff = abs(aspect_ratio - target_aspect_ratio)
+        if ratio_diff < best_ratio_diff:
+            best_ratio_diff = ratio_diff
+            best_ratio = ratio
+        elif ratio_diff == best_ratio_diff:
+            if area > 0.5 * image_size * image_size * ratio[0] * ratio[1]:
+                best_ratio = ratio
+    return best_ratio
+
+
+def find_closest_area_weighted_aspect_ratio(aspect_ratio, target_ratios, width, height, image_size):
+    """
+    Find the best number of tiles based on the aspect ratio and the area covered by the tiles.
+    """
+    best_factor = float('-inf')
+    best_ratio = (1, 1)
+    area = width * height
+    for ratio in target_ratios:
+        target_aspect_ratio = ratio[0] / ratio[1]
+        factor_based_on_area_n_ratio = (
+            min((ratio[0]*ratio[1]*image_size*image_size)/ area, 0.6) *
+            min(target_aspect_ratio/aspect_ratio, aspect_ratio/target_aspect_ratio))
+        if factor_based_on_area_n_ratio > best_factor:
+            best_factor = factor_based_on_area_n_ratio
+            best_ratio = ratio
+    return best_ratio
+
+
+class ImageTransform:
+    """Image transformation."""
+
+    def __init__(self, input_size, vision_model_type):
+        self._transform = _build_transform(input_size, vision_model_type)
+        self._vision_model_type = vision_model_type
+
+    def __call__(self, img, img_h, img_w, use_tiling=False, max_num_tiles=1, use_thumbnail=False, augment=False, find_closest_aspect_ratio_fn=find_closest_aspect_ratio):
+        assert not augment, "Image augmentation not implemented."
+        if use_tiling:
+            assert img_h == img_w, "dynamic tiling expects equal tile height and width"
+            imgs = dynamic_preprocess(
+                img, min_num=1, max_num=max_num_tiles, image_size=img_h, use_thumbnail=use_thumbnail,
+                find_closest_aspect_ratio_fn=find_closest_aspect_ratio_fn)
+            imgs = [self._transform(img) for img in imgs]
+        else:
+            imgs = [self._transform(img)]
+
+        return imgs
+
+
+# From https://github.com/OpenGVLab/InternVL/blob/c62fa4f7c850165d7386bdc48ac6bc5a6fab0864/internvl_chat/internvl/train/dataset.py#L702
+# Copyright (c) 2023 OpenGVLab.
+def dynamic_preprocess(
+    image, min_num=1, max_num=6, image_size=448, use_thumbnail=False,
+    find_closest_aspect_ratio_fn=find_closest_aspect_ratio):
+    orig_width, orig_height = image.size
+    aspect_ratio = orig_width / orig_height
+
+    # calculate the existing image aspect ratio
+    target_ratios = set(
+        (i, j) for n in range(min_num, max_num + 1) for i in range(1, n + 1) for j in range(1, n + 1) if
+        i * j <= max_num and i * j >= min_num)
+    target_ratios = sorted(target_ratios, key=lambda x: x[0] * x[1])
+
+    # find the closest aspect ratio to the target
+    target_aspect_ratio = find_closest_aspect_ratio_fn(
+        aspect_ratio, target_ratios, orig_width, orig_height, image_size)
+
+    # calculate the target width and height
+    target_width = image_size * target_aspect_ratio[0]
+    target_height = image_size * target_aspect_ratio[1]
+    blocks = target_aspect_ratio[0] * target_aspect_ratio[1]
+
+    # resize the image
+    resized_img = image.resize((target_width, target_height))
+    processed_images = []
+    for i in range(blocks):
+        box = (
+            (i % (target_width // image_size)) * image_size,
+            (i // (target_width // image_size)) * image_size,
+            ((i % (target_width // image_size)) + 1) * image_size,
+            ((i // (target_width // image_size)) + 1) * image_size
+        )
+        # split the image
+        split_img = resized_img.crop(box)
+        processed_images.append(split_img)
+    assert len(processed_images) == blocks
+    if use_thumbnail and len(processed_images) != 1:
+        thumbnail_img = image.resize((image_size, image_size))
+        processed_images.append(thumbnail_img)
+    return processed_images
+
+
+# Based on https://github.com/openai/CLIP/blob/dcba3cb2e2827b402d2701e7e1c7d9fed8a20ef1/clip/clip.py#L79
+# and https://github.com/OpenGVLab/InternVL/blob/aa521e6eb1df4cf153aa4118fcf13e673c055d46/internvl_chat/internvl/train/dataset.py#L276
+def _build_transform(input_size, vision_model_type):
+    if vision_model_type in ("siglip", "internvit", "internvit300M", "radio", "radio-g", "cradio-g"):
+        pixel_mean, pixel_std = pixel_statistics[vision_model_type]
+
+        transform = T.Compose([
+            T.Lambda(lambda img: img.convert('RGB') if img.mode != 'RGB' else img),
+            T.Resize((input_size, input_size), interpolation=InterpolationMode.BICUBIC),
+            T.ToTensor(),
+            T.Normalize(mean=pixel_mean, std=pixel_std)
+        ])
+    elif vision_model_type == "clip":
+        pixel_mean, pixel_std = pixel_statistics[vision_model_type]
+
+        transform = Compose([
+            T.Resize((input_size, input_size), interpolation=InterpolationMode.BICUBIC),
+            T.Lambda(lambda img: img.convert('RGB') if img.mode != 'RGB' else img),
+            T.ToTensor(),
+            T.Normalize(mean=pixel_mean, std=pixel_std),
+        ])
+    elif vision_model_type.startswith("hf://"):
+        from megatron.core.models.huggingface.module import get_hf_model_type
+
+        model_type = get_hf_model_type(vision_model_type)
+        if "siglip" in model_type:
+            from transformers.models.siglip.image_processing_siglip import SiglipImageProcessor
+
+            processor = SiglipImageProcessor(size={"height": input_size, "width": input_size})
+
+            def transform(x):
+                x = x.convert("RGB") if x.mode != "RGB" else x
+                x = processor(x, return_tensors="pt")
+                return x["pixel_values"][0]
+        else:
+            raise NotImplementedError(f"image processing not defined for huggingface model {vision_model_type}")
+    else:
+        raise NotImplementedError(f"image processing not defined for vision model {vision_model_type}")
+
+    return transform
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/layer_scaling.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/layer_scaling.py
new file mode 100644
index 0000000000000000000000000000000000000000..b3d2881b3158c51f8b8c34b2a35d2a2363d386c5
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/layer_scaling.py
@@ -0,0 +1,48 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+from functools import partial
+
+import torch
+
+from megatron.core.transformer.transformer_layer import TransformerLayer
+from megatron.core.typed_torch import copy_signature
+
+
+def _bias_dropout_add_func_layer_scaling(ls, x_with_bias, residual, prob, training):
+    x, bias = x_with_bias  # unpack
+    residual = residual if residual.dtype == x.dtype else residual.to(x.dtype)
+    if bias is not None:
+        x = x + bias
+        out = torch.nn.functional.dropout(x, p=prob, training=training)
+        out = residual + out * ls
+        return out
+    else:
+        out = torch.nn.functional.dropout(x, p=prob, training=training)
+        out = residual + out * ls
+        return out
+
+
+def bias_dropout_add_unfused_layer_scaling(ls, training):
+    """Bias-dropout-add as in Megatron but with added LayerScaling handling."""
+
+    def _bias_dropout_add(x_with_bias, residual, prob):
+        return _bias_dropout_add_func_layer_scaling(ls, x_with_bias, residual, prob, training)
+
+    return _bias_dropout_add
+
+
+def get_bias_dropout_add_layer_scaling(ls, training, fused):
+    """Bias-dropout-add as in Megatron but with added LayerScaling handling."""
+    assert not fused, "Fused bias-dropout-add not implemented for LayerScaling."
+    return bias_dropout_add_unfused_layer_scaling(ls, training)
+
+
+# Add LayerScaling to our default TransformerLayer.
+class LayerScalingTransformerLayer(TransformerLayer):
+    @copy_signature(TransformerLayer.__init__)
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.ls1 = torch.nn.Parameter(torch.ones(self.config.hidden_size))
+        self.ls2 = torch.nn.Parameter(torch.ones(self.config.hidden_size))
+
+        self.self_attn_bda = partial(self.self_attn_bda, self.ls1)
+        self.mlp_bda = partial(self.mlp_bda, self.ls2)
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/layer_specs.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/layer_specs.py
new file mode 100644
index 0000000000000000000000000000000000000000..ad24850b631deb7a2f2515b974a29f6cccda5f3e
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/layer_specs.py
@@ -0,0 +1,205 @@
+# Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved.
+import torch
+
+from megatron.core.fusions.fused_bias_dropout import get_bias_dropout_add
+from megatron.core.ssm.mamba_block import MambaStack, MambaStackSubmodules
+from megatron.core.ssm.mamba_layer import MambaLayer, MambaLayerSubmodules
+from megatron.core.ssm.mamba_mixer import MambaMixer, MambaMixerSubmodules
+from megatron.core.ssm.mlp_layer import MLPLayer
+from megatron.core.tensor_parallel.layers import ColumnParallelLinear, RowParallelLinear
+from megatron.core.transformer.attention import SelfAttention, SelfAttentionSubmodules
+from megatron.core.transformer.dot_product_attention import DotProductAttention
+from megatron.core.transformer.enums import AttnMaskType
+from megatron.core.transformer.identity_op import IdentityOp
+from megatron.core.transformer.mlp import MLP, MLPSubmodules
+from megatron.core.transformer.spec_utils import ModuleSpec
+from megatron.core.transformer.transformer_layer import TransformerLayer, TransformerLayerSubmodules
+from megatron.core.typed_torch import not_none
+from megatron.core.extensions.transformer_engine import HAVE_TE
+
+if HAVE_TE:
+    from megatron.core.extensions.transformer_engine import (
+        TEColumnParallelLinear,
+        TEDotProductAttention,
+        TELayerNormColumnParallelLinear,
+        TENorm,
+        TERowParallelLinear,
+    )
+else:
+    (
+        TEColumnParallelLinear,
+        TEDotProductAttention,
+        TELayerNormColumnParallelLinear,
+        TENorm,
+        TERowParallelLinear,
+    ) = (None, None, None, None, None)
+
+try:
+    import apex
+
+    from megatron.core.fusions.fused_layer_norm import FusedLayerNorm
+    from megatron.core.transformer.torch_norm import WrappedTorchNorm
+
+    HAVE_APEX = True
+    LNImpl = FusedLayerNorm
+except ImportError:
+    import warnings
+
+    from megatron.core.transformer.torch_norm import WrappedTorchNorm
+
+    warnings.warn(f'Apex is not installed. Falling back to Torch Norm')
+    LNImpl = WrappedTorchNorm
+
+
+def get_layer_spec(is_vit, normalization) -> ModuleSpec:
+    attn_mask_type = AttnMaskType.no_mask if is_vit else AttnMaskType.causal
+    if normalization == "LayerNorm":
+        norm = LNImpl
+    elif normalization == "RMSNorm":
+        if HAVE_TE:
+            norm = TENorm
+        else:
+            version = torch.__version__.split('.')
+            version_geq_2_4 = int(TORCH_VERSION[0]) > 2 or (
+                int(TORCH_VERSION[0]) == 2 and int(TORCH_VERSION[1]) >= 4
+            )
+            assert version_geq_2_4, "Torch version >= 2.4.0 is required for RMSNorm"
+            if HAVE_APEX:
+                warnings.warn(f'Apex does not support RMSNorm. Falling back to Torch Norm')
+            norm = WrappedTorchNorm
+    else:
+        raise RuntimeError("unknown normalization", normalization)
+
+    mlp = get_mlp_module_spec(use_te=False)  # doesn't include norm.
+
+    return ModuleSpec(
+        module=TransformerLayer,
+        submodules=TransformerLayerSubmodules(
+            input_layernorm=not_none(norm),
+            self_attention=ModuleSpec(
+                module=SelfAttention,
+                params={"attn_mask_type": attn_mask_type},
+                submodules=SelfAttentionSubmodules(
+                    linear_qkv=ColumnParallelLinear,
+                    core_attention=DotProductAttention,
+                    linear_proj=RowParallelLinear,
+                    q_layernorm=IdentityOp,
+                    k_layernorm=IdentityOp,
+                ),
+            ),
+            self_attn_bda=get_bias_dropout_add,
+            pre_mlp_layernorm=not_none(norm),
+            mlp=mlp,
+            mlp_bda=get_bias_dropout_add,
+        ),
+    )
+
+
+def get_layer_spec_te(is_vit=False, padding=False) -> ModuleSpec:
+    attn_mask_type = AttnMaskType.no_mask if is_vit else AttnMaskType.causal
+    # Padding mask is needed for e.g. Context Parallel.
+    if padding:
+        assert not is_vit, "padding_causal mask not used with ViT"
+        attn_mask_type = AttnMaskType.padding_causal
+
+    mlp = get_norm_mlp_module_spec_te()
+    return ModuleSpec(
+        module=TransformerLayer,
+        submodules=TransformerLayerSubmodules(
+            self_attention=ModuleSpec(
+                module=SelfAttention,
+                params={"attn_mask_type": attn_mask_type},
+                submodules=SelfAttentionSubmodules(
+                    linear_qkv=not_none(TELayerNormColumnParallelLinear),
+                    core_attention=not_none(TEDotProductAttention),
+                    linear_proj=TERowParallelLinear,
+                    q_layernorm=IdentityOp,
+                    k_layernorm=IdentityOp,
+                ),
+            ),
+            self_attn_bda=get_bias_dropout_add,
+            pre_mlp_layernorm=IdentityOp,
+            mlp=mlp,
+            mlp_bda=get_bias_dropout_add,
+        ),
+    )
+
+
+def get_mamba_layer_spec_te(padding=False) -> ModuleSpec:
+    attn_mask_type = AttnMaskType.causal
+    # Padding mask is needed for e.g. Context Parallel.
+    if padding:
+        attn_mask_type = AttnMaskType.padding_causal
+
+    return ModuleSpec(
+        module=MambaStack,
+        submodules=MambaStackSubmodules(
+            mamba_layer=ModuleSpec(
+                module=MambaLayer,
+                submodules=MambaLayerSubmodules(
+                    mixer=ModuleSpec(
+                        module=MambaMixer,
+                        submodules=MambaMixerSubmodules(
+                            in_proj=TELayerNormColumnParallelLinear, out_proj=TERowParallelLinear
+                        ),
+                    ),
+                    mamba_bda=get_bias_dropout_add,
+                ),
+            ),
+            # Started with spec from gpt_layer_specs.py (with MLP removed)
+            # Using the TE spec because we had problems getting the non-TE spec
+            # working
+            attention_layer=ModuleSpec(
+                module=TransformerLayer,
+                submodules=TransformerLayerSubmodules(
+                    self_attention=ModuleSpec(
+                        module=SelfAttention,
+                        params={"attn_mask_type": attn_mask_type},
+                        submodules=SelfAttentionSubmodules(
+                            linear_qkv=not_none(TELayerNormColumnParallelLinear),
+                            core_attention=not_none(TEDotProductAttention),
+                            linear_proj=TERowParallelLinear,
+                        ),
+                    ),
+                    self_attn_bda=get_bias_dropout_add,
+                ),
+            ),
+            # Started with spec from gpt_layer_specs.py
+            # Using the TE spec because we had problems getting the non-TE spec
+            # working
+            mlp_layer=ModuleSpec(
+                module=MLPLayer,
+                submodules=TransformerLayerSubmodules(
+                    mlp=ModuleSpec(
+                        module=MLP,
+                        submodules=MLPSubmodules(
+                            linear_fc1=not_none(TELayerNormColumnParallelLinear),
+                            linear_fc2=not_none(TERowParallelLinear),
+                        ),
+                    ),
+                    mlp_bda=get_bias_dropout_add,
+                ),
+            ),
+        ),
+    )
+
+
+def get_mlp_module_spec(use_te: bool = True) -> ModuleSpec:
+    # Dense MLP w/ or w/o TE modules.
+    return ModuleSpec(
+        module=MLP,
+        submodules=MLPSubmodules(
+            linear_fc1=not_none(TEColumnParallelLinear) if use_te else ColumnParallelLinear,
+            linear_fc2=not_none(TERowParallelLinear) if use_te else RowParallelLinear,
+        ),
+    )
+
+
+def get_norm_mlp_module_spec_te() -> ModuleSpec:
+    return ModuleSpec(
+        module=MLP,
+        submodules=MLPSubmodules(
+            linear_fc1=not_none(TELayerNormColumnParallelLinear),
+            linear_fc2=not_none(TERowParallelLinear),
+        ),
+    )
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/manual_prompts.json b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/manual_prompts.json
new file mode 100644
index 0000000000000000000000000000000000000000..b0dfd848015b9b93143757526083e38dbbde3611
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/manual_prompts.json
@@ -0,0 +1,48 @@
+{
+    "COMMENT": "Sources for these prompts include https://huggingface.co/datasets/liuhaotian/LLaVA-Pretrain/viewer and https://huggingface.co/datasets/HuggingFaceM4/M3IT",
+    "Captioning": {
+        "raw": [
+            "Can you briefly explain what you see in the image?",
+            "Describe what's happening in this image in one short sentence.",
+            "Write a short caption that accurately represents the content of this image.",
+            "Please generate a descriptive caption for the image provided.",
+            "How would you summarize the scene depicted in the picture in short?",
+            "Describe the image briefly.",
+            "Write a succinct description of the image, capturing its main components, the relationships between them, and any notable details.",
+            "Create a concise caption that accurately describes the main elements in the image provided.",
+            "Write a brief, yet comprehensive, description of the image.",
+            "Describe the image in a clear and concise manner.",
+            "For the given image, provide a one-sentence summary that captures the most important details.",
+            "Generate a short caption for the picture.",
+            "Write a short and informative description that highlights the primary subjects and actions occurring in the given image.",
+            "Provide a concise and informative caption for the image, focusing on the primary subjects.",
+            "Write a clear description of the image, make sure the key features are well covered.",
+            "Offer a succinct explanation of the picture presented."
+        ]
+    },
+    "CaptioningPretraining": {
+        "raw": [
+            "Generate a short caption of the image.",
+            "Describe the image concisely.",
+            "Provide a brief description of the given image."
+        ],
+        "llava": [
+            "Give a brief description of image.",
+            "Give a brief description of the image.",
+            "Provide a brief description of the given image.",
+            "Provide a one-sentence caption for the provided image.",
+            "Write a terse but informative summary of the picture.",
+            "Describe the image concisely.",
+            "Generate a clear and concise summary of the photo."
+        ]
+    },
+    "OCR": {
+        "raw": [
+            "Can you read the text from image and output here?",
+            "Extract and document the text from the provided image.",
+            "Converting the text embedded in this image into a readable document.",
+            "Transcribe all the text you find.",
+            "Can you extract all visible text from the image here?"
+        ]
+    }
+}
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/model.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/model.py
new file mode 100644
index 0000000000000000000000000000000000000000..494a854099e835aaf4e05e7b2c446f8cd305e032
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/model.py
@@ -0,0 +1,270 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+import warnings
+import logging
+from copy import deepcopy
+
+import torch
+from config import get_language_model_config, get_vision_model_config, get_vision_projection_config
+from layer_specs import (get_layer_spec, get_layer_spec_te, get_mlp_module_spec, get_norm_mlp_module_spec_te,
+                         get_mamba_layer_spec_te)
+
+from megatron.core.models.multimodal.llava_model import IMAGE_TOKEN, LLaVAModel
+from megatron.core.models.vision.clip_vit_model import get_num_image_embeddings
+from megatron.training import get_args, get_tokenizer, print_rank_0
+from megatron.training.arguments import core_transformer_config_from_args
+from megatron.core.utils import log_single_rank
+
+
+def model_provider(
+    pre_process=True, post_process=True, add_encoder=True, add_decoder=True, parallel_output=True,
+    vp_stage=None, config=None, pg_collection=None
+) -> LLaVAModel:
+    """Builds the model.
+
+    Args:
+        pre_process (bool): Include the embedding layer in the gpt decoder (used with pipeline parallelism). Defaults to True.
+        post_process (bool): Include an output layer and a layernorm in the gpt decoder (used with pipeline parallelism). Defaults to True.
+        add_encoder (bool): Construct the encoder module (used with pipeline parallelism). Defaults to True. When we use pipelining, the encoder
+            will live on only a subset of the pipeline stages (specifically, only the first stage).
+        add_decoder (bool): Construct the decoder module (used with pipeline parallelism). Defaults to True. When we use pipelining, the decoder
+            will live on only a subset of the pipeline stages (specifically, every stage after the first one).
+        parallel_output (bool): Enable parallel model output.
+        vp_stage: Optional virtual pipeline stage. Used with virtual pipeline parallelism.
+        config: Optional transformer config. If None, will be created from args.
+        pg_collection: Optional process group collection. If None, will use default.
+
+    Returns:
+        model: A multimodal model.
+    """
+    args = get_args()
+    use_te = args.use_te
+
+    print_rank_0('building a multimodal model ...')
+
+    num_image_embeddings = get_num_image_embeddings(
+        args.img_h,
+        args.img_w,
+        args.patch_dim,
+        args.vision_model_type,
+        args.disable_vision_class_token,
+        1,
+        args.pixel_shuffle,
+        args.use_tile_tags,
+        args.max_num_tiles,
+        args.tokenizer_prompt_format
+    )
+    old_seq_length = args.seq_length
+    args.seq_length = args.encoder_seq_length = num_image_embeddings
+    if old_seq_length != args.seq_length:
+        log_single_rank(
+            logging.getLogger(__name__),
+            logging.WARNING,
+            f"Changed seq_length and encoder_seq_length (vision model sequence length) from {old_seq_length} to num_image_tokens ({num_image_embeddings})"
+        )
+
+    max_num_image_embeddings = max((args.max_num_tiles + int(args.use_thumbnail)), args.num_frames) * num_image_embeddings
+
+    assert (
+        args.decoder_seq_length is not None
+    ), "Please provide --decoder-seq-length to set the language model sequence length"
+    assert (
+        args.decoder_seq_length > max_num_image_embeddings
+    ), "Language model sequence length must be greater than the maximum number of image embeddings"
+    if args.decoder_seq_length > args.max_position_embeddings:
+        args.max_position_embeddings = args.decoder_seq_length
+        warnings.warn(
+            f"Expanded max_position_embeddings to {args.max_position_embeddings} to accommodate the maximum language model sequence length"
+        )
+
+    language_model_type = args.language_model_type
+    vision_model_type = args.vision_model_type
+
+    base_config = core_transformer_config_from_args(get_args())
+    base_config.language_model_type = args.language_model_type
+    base_config.vision_model_type = args.vision_model_type
+    base_config.calculate_per_token_loss = True
+
+    language_config = deepcopy(base_config)
+    language_config = get_language_model_config(language_config)
+
+    if language_model_type.startswith("hf://"):
+        assert args.tensor_model_parallel_size == 1, "Huggingface models do not support --tensor-model-parallel-size > 1"
+        assert args.pipeline_model_parallel_size < 2, "Huggingface models do not support --pipeline-model-parallel-size > 1"
+        assert not args.sequence_parallel, "Huggingface models do not support --sequence-parallel"
+        assert args.context_parallel_size < 2, "Huggingface models do not support --context-parallel-size > 1"
+
+    if language_model_type.startswith("hf://"):
+        language_transformer_layer_spec = None
+    elif use_te:
+        # Padding mask needed for SP/CP.
+        padding = args.context_parallel_size > 1 and args.sequence_parallel
+        if args.language_model_type.startswith('nemotron5-hybrid'):
+            language_transformer_layer_spec = get_mamba_layer_spec_te(padding=padding)
+        else:
+            language_transformer_layer_spec = get_layer_spec_te(
+                is_vit=False, padding=padding
+            )  # TENorm detects LayerNorm/RMS automatically.
+    else:
+        language_transformer_layer_spec = get_layer_spec(
+            is_vit=False, normalization=language_config.normalization
+        )
+
+    vision_config = deepcopy(base_config)
+    vision_config = get_vision_model_config(
+        vision_config, apply_query_key_layer_scaling=args.apply_query_key_layer_scaling
+    )
+    if vision_model_type.startswith("hf://"):
+        assert not args.sequence_parallel, "Huggingface models do not support --sequence-parallel"
+        assert args.context_parallel_size < 2, "Huggingface models do not support --context-parallel-size > 1"
+
+    if vision_model_type in ["clip", "siglip", "radio", "cradio-g"]:
+        if use_te:
+            vision_transformer_layer_spec = get_layer_spec_te(
+                is_vit=True
+            )  # TENorm detects LayerNorm/RMS automatically.
+        else:
+            vision_transformer_layer_spec = get_layer_spec(
+                is_vit=True, normalization=vision_config.normalization
+            )
+    elif vision_model_type == "radio-g":
+        if use_te:
+            from radio.radio_g import get_radio_g_layer_spec_te
+            vision_transformer_layer_spec = get_radio_g_layer_spec_te()  # TENorm detects LayerNorm/RMS automatically.
+        else:
+            from radio.radio_g import get_radio_g_layer_spec
+            vision_transformer_layer_spec = get_radio_g_layer_spec(
+                normalization=vision_config.normalization
+            )
+    elif vision_model_type == "internvit":
+        from nvlm.internvit import get_internvit_layer_spec
+        vision_transformer_layer_spec = get_internvit_layer_spec(use_te=use_te)
+    elif vision_model_type == "internvit300M":
+        from nvlm.internvit import get_internvit300M_layer_spec
+        vision_transformer_layer_spec = get_internvit300M_layer_spec(use_te=use_te)
+    elif vision_model_type.startswith("hf://"):
+        vision_transformer_layer_spec = None
+    else:
+        raise RuntimeError("unsupported vision model type", vision_model_type)
+
+    vision_projection_config = deepcopy(base_config)
+
+    vision_projection_config = get_vision_projection_config(
+        vision_projection_config, language_config.hidden_size
+    )
+
+    # Make sure vision model pipeline parallel size is not inherited from the language model pipeline parallel size.
+    vision_config.pipeline_model_parallel_size = 1
+    vision_projection_config.pipeline_model_parallel_size = vision_config.pipeline_model_parallel_size
+
+    # Make sure the vision model does not inherit first and last pipeline num layers from the language model.
+    vision_config.first_pipeline_num_layers = vision_config.last_pipeline_num_layers = None
+
+    if vision_projection_config.normalization:
+        vision_projection_layer_spec = get_norm_mlp_module_spec_te().submodules
+    else:
+        vision_projection_layer_spec = get_mlp_module_spec(use_te=use_te).submodules
+
+    # Toggle --recompute* for the vision and language model separately.
+    if args.recompute_vision:
+        if vision_config.recompute_method is not None and vision_config.recompute_granularity is not None:
+            vision_config.recompute_num_layers = vision_config.num_layers
+    else:
+        vision_config.recompute_granularity = None
+        vision_config.recompute_method = None
+        vision_config.recompute_num_layers = None
+
+    vision_projection_config.recompute_granularity = None
+    vision_projection_config.recompute_method = None
+    vision_projection_config.recompute_num_layers = None
+
+    # TODO: Vision model and projection do not use SP/CP yet.
+    vision_config.sequence_parallel = False
+    vision_config.context_parallel_size = 1
+    vision_config.tp_comm_overlap = False
+
+    vision_projection_config.sequence_parallel = False
+    vision_projection_config.context_parallel_size = 1
+    vision_projection_config.tp_comm_overlap = False
+
+    tokenizer = get_tokenizer()
+    image_token_index = tokenizer.convert_tokens_to_ids(IMAGE_TOKEN)
+    assert image_token_index is not None, f"IMAGE_TOKEN={IMAGE_TOKEN} needs to be added using the --special-tokens arg."
+
+    tile_tags = _get_tile_tags(args, tokenizer)
+
+    model = LLaVAModel(
+        language_transformer_config=language_config,
+        language_transformer_layer_spec=language_transformer_layer_spec,
+        language_vocab_size=args.padded_vocab_size,
+        language_max_sequence_length=args.decoder_seq_length,
+        vision_transformer_config=vision_config,
+        vision_transformer_layer_spec=vision_transformer_layer_spec,
+        drop_vision_class_token=args.disable_vision_class_token,
+        vision_projection_config=vision_projection_config,
+        vision_projection_layer_spec=vision_projection_layer_spec,
+        vision_projection_type="mlp",
+        allow_missing_vision_projection_checkpoint=args.allow_missing_vision_projection_checkpoint,
+        parallel_output=parallel_output,
+        share_embeddings_and_output_weights=not args.untie_embeddings_and_output_weights,
+        language_position_embedding_type=args.position_embedding_type,
+        language_rotary_percent=args.rotary_percent,
+        pre_process=pre_process,
+        post_process=post_process,
+        add_encoder=add_encoder,
+        add_decoder=add_decoder,
+        img_h=args.img_h,
+        img_w=args.img_w,
+        patch_dim=args.patch_dim,
+        language_rotary_base=args.rotary_base,
+        language_rope_scaling=args.use_rope_scaling,
+        hybrid_layer_pattern=args.hybrid_layer_pattern,
+        fp16_lm_cross_entropy=args.fp16_lm_cross_entropy,
+        image_token_index=image_token_index,
+        pixel_shuffle=args.pixel_shuffle,
+        tile_tags=tile_tags,
+        max_num_tiles=args.max_num_tiles,
+        tokenizer_type=args.tokenizer_prompt_format,
+    )
+
+    model.freeze(
+        freeze_language_model=args.freeze_LM,
+        freeze_vision_model=args.freeze_ViT,
+        freeze_vision_projection=False,
+    )
+
+    return model
+
+
+def _get_tile_tags(args, tokenizer):
+    """Tile tags are used in NVLM to surround image tiles with text tags."""
+    if not args.use_tile_tags:
+        return None
+
+    # We expect the tokenized length of the tags is same.
+    if args.max_num_tiles < 10:
+        thumbnail_tag_text = "<tile_global_thumbnail>"
+        if args.tokenizer_prompt_format == "nvlm-yi-34b":
+            thumbnail_tag_text = "<tile_global>"
+
+        if args.tokenizer_prompt_format.startswith("nemotron"):
+            tile_tags_text = [f"<tile_{i:02d}>" for i in range(1, args.max_num_tiles + 1)] + [thumbnail_tag_text]
+        else:
+            tile_tags_text = [f"<tile_{i}>" for i in range(1, args.max_num_tiles + 1)] + [thumbnail_tag_text]
+    elif args.max_num_tiles <= 12:
+        thumbnail_tag_text = "<tile_global_thumbnail0>"
+        if args.tokenizer_prompt_format == "nvlm-yi-34b":
+            thumbnail_tag_text = "<tile_global0>"
+        elif args.tokenizer_prompt_format.startswith("nemotron") or args.tokenizer_prompt_format == "llama3p1":
+            thumbnail_tag_text = "<tile_global_thumbnail>"
+        tile_tags_text = [f"<tile_{i:02d}>" for i in range(1, args.max_num_tiles + 1)] + [thumbnail_tag_text]
+    else:
+        raise ValueError("We only support max_num_tiles <= 12 when using nvlm image_tag_type")
+
+    start_idx = 0
+    if tokenizer._prompt_config.has_bos:
+        start_idx = 1
+
+    # Convert to tokens [num_tiles, tile_seq_len].
+    tile_tags = [tokenizer.tokenize(t)[start_idx:] for t in tile_tags_text]
+
+    return tile_tags
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/model_converter/clip_converter.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/model_converter/clip_converter.py
new file mode 100644
index 0000000000000000000000000000000000000000..696c810890f9767a8eb5b293eef3f907898db9ed
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/model_converter/clip_converter.py
@@ -0,0 +1,163 @@
+# Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved.
+import argparse
+import os
+
+import torch
+
+import clip
+
+
+def convert(download_root, output_path, tensor_parallel_size, use_te):
+    device = "cuda"
+
+    model, _ = clip.load("ViT-L/14@336px", device=device, download_root=download_root)
+
+    state_dict = model.state_dict()
+    new_state_dicts = [{"model": dict()} for _ in range(tensor_parallel_size)]
+
+    # Indices from mapping pytorch multihead attention to megatron.
+    kv_channels = 64
+    hidden_dim = 1024
+    num_heads = 16
+    indices = []
+    for i in range(num_heads):
+        lb = i * kv_channels
+        ub = (i + 1) * kv_channels
+        indices.append(torch.arange(lb, ub, dtype=torch.int))
+        indices.append(torch.arange(hidden_dim + lb, hidden_dim + ub, dtype=torch.int))
+        indices.append(torch.arange(2 * hidden_dim + lb, 2 * hidden_dim + ub, dtype=torch.int))
+
+    indices = torch.cat(indices)
+
+    for name, tensor in state_dict.items():
+        # Skip text model.
+        if "visual" not in name:
+            continue
+
+        # Skip final layers not used in our model.
+        if name == "visual.proj" or "ln_post" in name:
+            continue
+
+        # Map parameter names to ones used in megatron.
+        new_name = ""
+        new_tensor = tensor
+        if new_tensor.dtype == torch.float16:
+            new_tensor = new_tensor.to(torch.float32)
+
+        # This is used for chunking some tensors to target tensor parallel size.
+        chunk_dim = None
+
+        if "class_embedding" in name:
+            new_name = "class_token"
+            # Our model uses class token that is expanded to input dimensions already.
+            new_tensor = new_tensor.expand(1, 1, -1)
+        elif "positional_embedding" in name:
+            new_name = "position_embeddings.weight"
+        elif "conv1" in name:
+            new_name = "conv1.weight"
+        elif "ln_pre.weight" in name:
+            new_name = "ln_pre.weight"
+        elif "ln_pre.bias" in name:
+            new_name = "ln_pre.bias"
+        elif "transformer.resblocks" in name:
+            layer_idx = name.split(".")[3]
+            base = f"decoder.layers.{layer_idx}"
+
+            if "attn.in_proj_weight" in name:
+                new_name = f"{base}.self_attention.linear_qkv.weight"
+                new_tensor = new_tensor[indices]
+                chunk_dim = 0
+            elif "attn.in_proj_bias" in name:
+                new_name = f"{base}.self_attention.linear_qkv.bias"
+                new_tensor = new_tensor[indices]
+                chunk_dim = 0
+            elif "attn.out_proj.weight" in name:
+                new_name = f"{base}.self_attention.linear_proj.weight"
+                chunk_dim = 1
+            elif "attn.out_proj.bias" in name:
+                new_name = f"{base}.self_attention.linear_proj.bias"
+            elif "ln_1.weight" in name:
+                new_name = f"{base}.input_layernorm.weight"
+                if use_te:
+                    new_name = f"{base}.self_attention.linear_qkv.layer_norm_weight"
+            elif "ln_1.bias" in name:
+                new_name = f"{base}.input_layernorm.bias"
+                if use_te:
+                    new_name = f"{base}.self_attention.linear_qkv.layer_norm_bias"
+            elif "mlp.c_fc.weight" in name:
+                new_name = f"{base}.mlp.linear_fc1.weight"
+                chunk_dim = 0
+            elif "mlp.c_fc.bias" in name:
+                new_name = f"{base}.mlp.linear_fc1.bias"
+                chunk_dim = 0
+            elif "mlp.c_proj.weight" in name:
+                new_name = f"{base}.mlp.linear_fc2.weight"
+                chunk_dim = 1
+            elif "mlp.c_proj.bias" in name:
+                new_name = f"{base}.mlp.linear_fc2.bias"
+            elif "ln_2.weight" in name:
+                new_name = f"{base}.pre_mlp_layernorm.weight"
+                if use_te:
+                    new_name = f"{base}.mlp.linear_fc1.layer_norm_weight"
+            elif "ln_2.bias" in name:
+                new_name = f"{base}.pre_mlp_layernorm.bias"
+                if use_te:
+                    new_name = f"{base}.mlp.linear_fc1.layer_norm_bias"
+
+        assert new_name != "", f"unexpected layer name {name}"
+
+        if chunk_dim is None:
+            new_tensors = [new_tensor for _ in range(tensor_parallel_size)]
+        else:
+            new_tensors = torch.chunk(new_tensor, tensor_parallel_size, dim=chunk_dim)
+
+        for i in range(tensor_parallel_size):
+            # chunk() creates a view of a bigger tensor. clone() is used here to avoid excessive storage.
+            new_state_dicts[i]["model"][new_name] = new_tensors[i].clone()
+
+            # TE sets _extra_state (for FP8 purposes), so set an empty one here for compatibility.
+            extra_state_layers = ("linear_qkv", "linear_proj", "linear_fc1", "linear_fc2")
+            is_extra_state_layer = any([l in new_name for l in extra_state_layers])
+            if use_te and is_extra_state_layer:
+                layer = new_name.split(".")[-2]
+                if layer in extra_state_layers:
+                    extra_state_name = (
+                        new_name[: new_name.rfind(".") + 1] + "_extra_state"
+                    )  # Replace the weight name.
+                    new_state_dicts[i]["model"][extra_state_name] = None
+
+    for i in range(tensor_parallel_size):
+        output_dir_tp = os.path.join(output_path, "iter_0000001", f"mp_rank_0{i}")
+        os.makedirs(output_dir_tp)
+        output_path_tp = os.path.join(output_dir_tp, "model_optim_rng.pt")
+        torch.save(new_state_dicts[i], output_path_tp)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="""
+Convert OpenAI CLIP VIT weights to megatron format.
+
+
+Example usage:
+python clip_converter.py --download-root /some/download/folder --output /some/output/folder --tensor-parallel-size 4
+""",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    parser.add_argument(
+        "--download-root", type=str, required=True, help="Download folder for OpenAI CLIP weights"
+    )
+    parser.add_argument(
+        "--output", type=str, required=True, help="output directory for megatron state dict file(s)"
+    )
+    parser.add_argument(
+        "--tensor-parallel-size", type=int, default=1, help="model tensor parallel size"
+    )
+    parser.add_argument("--use-te", action="store_true", help="Use Transformer Engine")
+
+    args = parser.parse_args()
+
+    convert(args.download_root, args.output, args.tensor_parallel_size, args.use_te)
+
+    print("done.")
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/model_converter/internvit_converter.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/model_converter/internvit_converter.py
new file mode 100644
index 0000000000000000000000000000000000000000..48404c2084cc84bead036b4ae82ce1d440dab101
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/model_converter/internvit_converter.py
@@ -0,0 +1,162 @@
+import argparse
+import os
+
+import torch
+from transformers import AutoModel
+
+
+def convert(model_name, output_path, tensor_parallel_size, use_te):
+    """Convert InternViT HF checkpoint to mcore."""
+    hf_model = AutoModel.from_pretrained(
+        model_name,
+        trust_remote_code=True
+    )
+
+    hf_state_dict = hf_model.state_dict()
+    new_state_dicts = [{"model": dict()} for _ in range(tensor_parallel_size)]
+
+    hidden_size = 3200
+    num_heads = 25
+    dim = 128
+
+    order = torch.ones(3 * hidden_size).long()
+
+    for j in range(num_heads):
+        for i in range(dim):
+            order[i + dim*3*j] = j*dim+i
+            order[dim + i + dim*3*j] = j*dim+i+num_heads*dim
+            order[dim*2 + i + dim*3*j] = j*dim+i+num_heads*dim*2
+
+    for name, tensor in hf_state_dict.items():
+        # Map parameter names to ones used in megatron.
+        new_name = ""
+        new_tensor = tensor
+
+        # This is used for chunking some tensors to target tensor parallel size.
+        chunk_dim = None
+
+        if "embeddings.class_embedding" in name:
+            new_name = "class_token"
+        elif "embeddings.patch_embedding.weight" in name:
+            new_name = "conv1.weight"
+        elif "embeddings.patch_embedding.bias" in name:
+            new_name = "conv1.bias"
+        elif "embeddings.position_embedding" in name:
+            new_name = "position_embeddings.weight"
+            new_tensor = new_tensor.squeeze(0)
+        elif "encoder.layers" in name:
+            layer_idx = name.split(".")[2]
+
+            base = f"decoder.layers.{layer_idx}"
+
+            head_dim = 128
+
+            if tensor_parallel_size == 1:
+                num_padded_heads = 25
+            elif tensor_parallel_size == 8:
+                # Note: 25 is not divisible by 8 and we don't currently support uneven heads split with tensor parallelism.
+                # So we pad with dummy all-zero heads. Please use a nice even number of attention heads in your model.
+                num_padded_heads = 32
+            else:
+                raise NotImplementedError("invalid tensor parallel size value:", tensor_parallel_size)
+
+            if "ls1" in name:
+                new_name = f"{base}.ls1"
+            elif "ls2" in name:
+                new_name = f"{base}.ls2"
+            elif "attn.qkv.weight" in name:
+                new_name = f"{base}.self_attention.linear_qkv.weight"
+                num_tensors = 3
+                padded_dim = head_dim * num_padded_heads * num_tensors
+                padded_tensor = torch.zeros((padded_dim, new_tensor.shape[-1]), dtype=new_tensor.dtype, device=new_tensor.device)
+                padded_tensor[:new_tensor.shape[0], :] = new_tensor[order]
+                new_tensor = padded_tensor
+                chunk_dim = 0
+            elif "attn.q_norm.weight" in name:
+                new_name = f"{base}.self_attention.q_layernorm.weight"
+                num_tensors = 1
+                padded_dim = head_dim * num_padded_heads * num_tensors
+                padded_tensor = torch.zeros(padded_dim, dtype=new_tensor.dtype, device=new_tensor.device)
+                padded_tensor[:new_tensor.shape[0]] = new_tensor
+                new_tensor = padded_tensor
+                chunk_dim = 0
+            elif "attn.k_norm.weight" in name:
+                new_name = f"{base}.self_attention.k_layernorm.weight"
+                num_tensors = 1
+                padded_dim = head_dim * num_padded_heads * num_tensors
+                padded_tensor = torch.zeros(padded_dim, dtype=new_tensor.dtype, device=new_tensor.device)
+                padded_tensor[:new_tensor.shape[0]] = new_tensor
+                new_tensor = padded_tensor
+                chunk_dim = 0
+            elif "attn.proj.weight" in name:
+                new_name = f"{base}.self_attention.linear_proj.weight"
+                num_tensors = 1
+                padded_dim = head_dim * num_padded_heads * num_tensors
+                padded_tensor = torch.zeros((new_tensor.shape[0], padded_dim), dtype=new_tensor.dtype, device=new_tensor.device)
+                padded_tensor[:, :new_tensor.shape[-1]] = new_tensor
+                new_tensor = padded_tensor
+                chunk_dim = 1
+            elif "attn.proj.bias" in name:
+                new_name = f"{base}.self_attention.linear_proj.bias"
+            elif "mlp.fc1.weight" in name:
+                new_name = f"{base}.mlp.linear_fc1.weight"
+                chunk_dim = 0
+            elif "mlp.fc1.bias" in name:
+                new_name = f"{base}.mlp.linear_fc1.bias"
+                chunk_dim = 0
+            elif "mlp.fc2.weight" in name:
+                new_name = f"{base}.mlp.linear_fc2.weight"
+                chunk_dim = 1
+            elif "mlp.fc2.bias" in name:
+                new_name = f"{base}.mlp.linear_fc2.bias"
+            elif "norm1" in name:
+                new_name = f"{base}.input_layernorm.weight"
+            elif "norm2" in name:
+                new_name = f"{base}.pre_mlp_layernorm.weight"
+            else:
+                raise RuntimeError("unexpected transformer layer name", name)
+        else:
+            raise RuntimeError("unexpected layer name", name)
+
+        assert new_name != "", f"unexpected layer name {name}"
+
+        # TE sets _extra_state (for FP8 purposes), so set an empty one here for compatibility.
+        extra_state_layers = ("linear_qkv", "linear_proj", "linear_fc1", "linear_fc2")
+        is_extra_state_layer = any([l in new_name for l in extra_state_layers])
+        if use_te and is_extra_state_layer:
+            layer = new_name.split(".")[-2]
+            if layer in extra_state_layers:
+                extra_state_name = (
+                    new_name[: new_name.rfind(".") + 1] + "_extra_state"
+                )  # Replace the weight name.
+                for i in range(tensor_parallel_size):
+                    new_state_dicts[i]["model"][extra_state_name] = None
+
+        if chunk_dim is None:
+            new_tensors = [new_tensor for _ in range(tensor_parallel_size)]
+        else:
+            new_tensors = torch.chunk(new_tensor, tensor_parallel_size, dim=chunk_dim)
+
+        for i in range(tensor_parallel_size):
+            new_state_dicts[i]["model"][new_name] = new_tensors[i].clone()
+
+    for i in range(tensor_parallel_size):
+        output_dir_tp = os.path.join(output_path, f"iter_0000001/mp_rank_0{i}")
+        os.makedirs(output_dir_tp, exist_ok=True)
+        output_path_tp = os.path.join(output_dir_tp, "model_optim_rng.pt")
+        torch.save(new_state_dicts[i], output_path_tp)
+        print("saved file", output_path_tp)
+
+    print("done")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="InternVIT HuggingFace to Mcore converter")
+    parser.add_argument("--model-name", type=str, default="OpenGVLab/InternViT-6B-448px-V1-5", help="Model name in HuggingFace")
+    parser.add_argument("--output-dir", type=str, required=True, help="Output directory for the mcore model.")
+    parser.add_argument("--use-te", action="store_true", default=True)
+    parser.add_argument("--tensor-parallel-size", type=int, required=True)
+
+    args = parser.parse_args()
+
+    convert(args.model_name, args.output_dir, args.tensor_parallel_size, args.use_te)
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/model_converter/radio_converter.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/model_converter/radio_converter.py
new file mode 100644
index 0000000000000000000000000000000000000000..459aef4a5d61db099b9d2547fbcec6533e379aaa
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/model_converter/radio_converter.py
@@ -0,0 +1,314 @@
+# Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved.
+import argparse
+import os
+
+import torch
+
+def convert_radio_h(output_path, tensor_parallel_size, use_te, version):
+    device = "cuda"
+
+    version = version if version is not None else 'radio_v2.5-h'
+    model = torch.hub.load('NVlabs/RADIO', 'radio_model', version=version, progress=True)
+
+    state_dict = model.state_dict()
+    new_state_dicts = [{"model": dict()} for _ in range(tensor_parallel_size)]
+
+    # Indices from mapping pytorch multihead attention to megatron.
+    kv_channels = 80 
+    hidden_dim = 1280 
+    num_heads = 16
+    indices = []
+    for i in range(num_heads):
+        lb = i * kv_channels
+        ub = (i + 1) * kv_channels
+        indices.append(torch.arange(lb, ub, dtype=torch.int))
+        indices.append(torch.arange(hidden_dim + lb, hidden_dim + ub, dtype=torch.int))
+        indices.append(torch.arange(2 * hidden_dim + lb, 2 * hidden_dim + ub, dtype=torch.int))
+
+    indices = torch.cat(indices)
+
+    for name, tensor in state_dict.items():
+        # Map parameter names to ones used in megatron.
+        new_name = ""
+        new_tensor = tensor
+        if new_tensor.dtype == torch.float16:
+            new_tensor = new_tensor.to(torch.float32)
+
+        # This is used for chunking some tensors to target tensor parallel size.
+        chunk_dim = None
+
+        if "summary_idxs" in name:
+            continue
+        elif "patch_generator" in name:
+            if "embedder" in name:
+                new_name = "embedder.weight"
+                chunk_dim = 0
+            elif "cls_token" in name:
+                new_name = "class_token"
+            elif "pos_embed" in name:
+                new_name = "position_embeddings"
+        elif "input_conditioner" in name:
+            continue
+        elif "blocks" in name:
+            layer_idx = name.split(".")[2]
+            base = f"decoder.layers.{layer_idx}"
+
+            if "attn.qkv.weight" in name:
+                new_name = f"{base}.self_attention.linear_qkv.weight"
+                new_tensor = new_tensor[indices]
+                chunk_dim = 0
+            elif "attn.qkv.bias" in name:
+                new_name = f"{base}.self_attention.linear_qkv.bias"
+                new_tensor = new_tensor[indices]
+                chunk_dim = 0
+            elif "attn.proj.weight" in name:
+                new_name = f"{base}.self_attention.linear_proj.weight"
+                chunk_dim = 1
+            elif "attn.proj.bias" in name:
+                new_name = f"{base}.self_attention.linear_proj.bias"
+            elif "norm1.weight" in name:
+                new_name = f"{base}.input_layernorm.weight"
+                if use_te:
+                    new_name = f"{base}.self_attention.linear_qkv.layer_norm_weight"
+            elif "norm1.bias" in name:
+                new_name = f"{base}.input_layernorm.bias"
+                if use_te:
+                    new_name = f"{base}.self_attention.linear_qkv.layer_norm_bias"
+            elif "mlp.fc1.weight" in name:
+                new_name = f"{base}.mlp.linear_fc1.weight"
+                chunk_dim = 0
+            elif "mlp.fc1.bias" in name:
+                new_name = f"{base}.mlp.linear_fc1.bias"
+                chunk_dim = 0
+            elif "mlp.fc2.weight" in name:
+                new_name = f"{base}.mlp.linear_fc2.weight"
+                chunk_dim = 1
+            elif "mlp.fc2.bias" in name:
+                new_name = f"{base}.mlp.linear_fc2.bias"
+            elif "norm2.weight" in name:
+                new_name = f"{base}.pre_mlp_layernorm.weight"
+                if use_te:
+                    new_name = f"{base}.mlp.linear_fc1.layer_norm_weight"
+            elif "norm2.bias" in name:
+                new_name = f"{base}.pre_mlp_layernorm.bias"
+                if use_te:
+                    new_name = f"{base}.mlp.linear_fc1.layer_norm_bias"
+
+        assert new_name != "", f"unexpected layer name {name}"
+
+        if chunk_dim is None:
+            new_tensors = [new_tensor for _ in range(tensor_parallel_size)]
+        else:
+            new_tensors = torch.chunk(new_tensor, tensor_parallel_size, dim=chunk_dim)
+
+        for i in range(tensor_parallel_size):
+            # chunk() creates a view of a bigger tensor. clone() is used here to avoid excessive storage.
+            new_state_dicts[i]["model"][new_name] = new_tensors[i].clone()
+
+            # TE sets _extra_state (for FP8 purposes), so set an empty one here for compatibility.
+            extra_state_layers = ("linear_qkv", "linear_proj", "linear_fc1", "linear_fc2")
+            is_extra_state_layer = any([l in new_name for l in extra_state_layers])
+            if use_te and is_extra_state_layer:
+                layer = new_name.split(".")[-2]
+                if layer in extra_state_layers:
+                    extra_state_name = (
+                        new_name[: new_name.rfind(".") + 1] + "_extra_state"
+                    )  # Replace the weight name.
+                    new_state_dicts[i]["model"][extra_state_name] = None
+
+    for i in range(tensor_parallel_size):
+        output_dir_tp = os.path.join(output_path, "iter_0000001", f"mp_rank_0{i}")
+        os.makedirs(output_dir_tp)
+        output_path_tp = os.path.join(output_dir_tp, "model_optim_rng.pt")
+        torch.save(new_state_dicts[i], output_path_tp)
+    with open(os.path.join(output_path, "latest_checkpointed_iteration.txt"), "w") as f:
+        f.write("1") 
+
+def convert_radio_g(output_path, tensor_parallel_size, use_te, version):
+    device = "cuda"
+
+    version = version if version is not None else 'radio_v2.5-g'
+    model = torch.hub.load('NVlabs/RADIO', 'radio_model', version=version, progress=True)
+
+    state_dict = model.state_dict()
+    new_state_dicts = [{"model": dict()} for _ in range(tensor_parallel_size)]
+
+    # Indices from mapping pytorch multihead attention to megatron.
+    kv_channels = 64
+    hidden_dim = 1536
+    num_heads = 24
+    ffn_hidden_dim = 4096
+    indices = []
+    for i in range(num_heads):
+        lb = i * kv_channels
+        ub = (i + 1) * kv_channels
+        indices.append(torch.arange(lb, ub, dtype=torch.int))
+        indices.append(torch.arange(hidden_dim + lb, hidden_dim + ub, dtype=torch.int))
+        indices.append(torch.arange(2 * hidden_dim + lb, 2 * hidden_dim + ub, dtype=torch.int))
+
+    indices = torch.cat(indices)
+
+    mlp_indices = []
+    step = ffn_hidden_dim // tensor_parallel_size
+    for i in range(tensor_parallel_size):
+        mlp_indices.append(torch.arange(i * step, (i + 1) * step, dtype=torch.int))
+        mlp_indices.append(torch.arange(ffn_hidden_dim + i * step, ffn_hidden_dim + (i + 1) * step, dtype=torch.int))
+
+    mlp_indices = torch.cat(mlp_indices)
+
+    for name, tensor in state_dict.items():
+        # Map parameter names to ones used in megatron.
+        new_names = []
+        new_tensor = tensor
+        if new_tensor.dtype == torch.float16:
+            new_tensor = new_tensor.to(torch.float32)
+        new_tensors = [new_tensor]
+
+        # This is used for chunking some tensors to target tensor parallel size.
+        chunk_dim = None
+
+        if "model" not in name:
+            continue;
+        elif "patch_generator" in name:
+            if "embedder.weight" in name:
+                new_names.append("embedder.weight")
+                chunk_dim = 0
+            elif "embedder.bias" in name:
+                new_names.append("embedder.bias")
+                chunk_dim = 0
+            elif "cls_token" in name:
+                new_names.append("class_token")
+            elif "pos_embed" in name:
+                new_names.append("position_embeddings")
+        elif "input_conditioner" in name:
+            continue;
+        elif "mask_token" in name:
+            new_names.append("mask_token")
+        elif "inner.norm" in name:
+            if "norm.weight" in name:
+                new_names.append("ln_post.weight")
+            elif "norm.bias" in name:
+                new_names.append("ln_post.bias")
+        elif "blocks" in name:
+            layer_idx = name.split(".")[3]
+            base = f"decoder.layers.{layer_idx}"
+
+            if "attn.qkv.weight" in name:
+                new_names.append(f"{base}.self_attention.linear_qkv.weight")
+                new_tensors[0] = new_tensors[0][indices]
+                chunk_dim = 0
+            elif "attn.qkv.bias" in name:
+                new_names.append(f"{base}.self_attention.linear_qkv.bias")
+                new_tensors[0] = new_tensors[0][indices]
+                chunk_dim = 0
+            elif "attn.proj.weight" in name:
+                new_names.append(f"{base}.self_attention.linear_proj.weight")
+                chunk_dim = 1
+            elif "attn.proj.bias" in name:
+                new_names.append(f"{base}.self_attention.linear_proj.bias")
+            elif "norm1.weight" in name:
+                new_name = f"{base}.input_layernorm.weight"
+                if use_te:
+                    new_name = f"{base}.self_attention.linear_qkv.layer_norm_weight"
+                new_names.append(new_name)
+            elif "norm1.bias" in name:
+                new_name = f"{base}.input_layernorm.bias"
+                if use_te:
+                    new_name = f"{base}.self_attention.linear_qkv.layer_norm_bias"
+                new_names.append(new_name)
+            elif "mlp.w12.weight" in name: 
+                new_names.append(f"{base}.mlp.linear_fc1.weight")
+                new_tensors[0] = new_tensors[0][mlp_indices]
+                chunk_dim = 0
+            elif "mlp.w12.bias" in name: 
+                new_names.append(f"{base}.mlp.linear_fc1.bias")
+                new_tensors[0] = new_tensors[0][mlp_indices]
+                chunk_dim = 0
+            elif "mlp.w3.weight" in name: 
+                new_names.append(f"{base}.mlp.linear_fc2.weight")
+                chunk_dim = 1
+            elif "mlp.w3.bias" in name: 
+                new_names.append(f"{base}.mlp.linear_fc2.bias")
+            elif "norm2.weight" in name:
+                new_name = f"{base}.pre_mlp_layernorm.weight"
+                if use_te:
+                    new_name = f"{base}.mlp.linear_fc1.layer_norm_weight"
+                new_names.append(new_name)
+            elif "norm2.bias" in name:
+                new_name = f"{base}.pre_mlp_layernorm.bias"
+                if use_te:
+                    new_name = f"{base}.mlp.linear_fc1.layer_norm_bias"
+                new_names.append(new_name)
+            elif "ls1.grandma" in name:
+                new_names.append(f"{base}.ls1")
+            elif "ls2.grandma" in name:
+                new_names.append(f"{base}.ls2")
+
+        assert len(new_names) == len(new_tensors), f"{new_names} {new_tensors}"
+
+        for new_name, new_tensor in zip(new_names, new_tensors):
+            if chunk_dim is None:
+                tp_new_tensors = [new_tensor for _ in range(tensor_parallel_size)]
+            else:
+                tp_new_tensors = torch.chunk(new_tensor, tensor_parallel_size, dim=chunk_dim)
+
+            for i in range(tensor_parallel_size):
+                # chunk() creates a view of a bigger tensor. clone() is used here to avoid excessive storage.
+                new_state_dicts[i]["model"][new_name] = tp_new_tensors[i].clone()
+
+                # TE sets _extra_state (for FP8 purposes), so set an empty one here for compatibility.
+                extra_state_layers = ("linear_qkv", "linear_proj", "linear_fc1", "linear_fc2")
+                is_extra_state_layer = any([l in new_name for l in extra_state_layers])
+                if use_te and is_extra_state_layer:
+                    layer = new_name.split(".")[-2]
+                    if layer in extra_state_layers:
+                        extra_state_name = (
+                            new_name[: new_name.rfind(".") + 1] + "_extra_state"
+                        )  # Replace the weight name.
+                        new_state_dicts[i]["model"][extra_state_name] = None
+
+    for i in range(tensor_parallel_size):
+        output_dir_tp = os.path.join(output_path, "iter_0000001", f"mp_rank_0{i}")
+        os.makedirs(output_dir_tp)
+        output_path_tp = os.path.join(output_dir_tp, "model_optim_rng.pt")
+        torch.save(new_state_dicts[i], output_path_tp)
+        with open(os.path.join(output_path, "latest_checkpointed_iteration.txt"), "w") as f:
+            f.write("1") 
+
+
+def convert(output_path, tensor_parallel_size, use_te, model_type, version):
+    if model_type == "radio_v2.5-h":
+        convert_radio_h(output_path, tensor_parallel_size, use_te, version)
+    elif model_type == "radio_v2.5-g":
+        convert_radio_g(output_path, tensor_parallel_size, use_te, version)
+    else:
+        raise NotImplementedError(f"Converter doesn't support model type {model_type}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="""
+Convert RADIO weights to megatron format.
+
+
+Example usage:
+python radio_converter.py --output /some/output/folder --tensor-parallel-size 4
+""",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    parser.add_argument(
+        "--output", type=str, required=True, help="output directory for megatron state dict file(s)"
+    )
+    parser.add_argument(
+        "--tensor-parallel-size", type=int, default=1, help="model tensor parallel size"
+    )
+    parser.add_argument("--use-te", action="store_true", help="Use Transformer Engine")
+    parser.add_argument("--model-type", required=True, type=str, choices=['radio_v2.5-h', 'radio_v2.5-g'], help="Type of radio to load for conversion")
+    parser.add_argument("--version", type=str, default=None, help="Version to pass to torch.hub.load. Can be a local path or a version RADIO on torch hub. By default use the version from the model type.")
+
+    args = parser.parse_args()
+
+    convert(args.output, args.tensor_parallel_size, args.use_te, args.model_type, args.version)
+
+    print("done.")
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/model_converter/siglip_converter.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/model_converter/siglip_converter.py
new file mode 100644
index 0000000000000000000000000000000000000000..666cda15ebdeb2818dd993344da5fe236616b6ab
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/model_converter/siglip_converter.py
@@ -0,0 +1,154 @@
+# Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved.
+import argparse
+import os
+from transformers import PaliGemmaForConditionalGeneration
+import torch
+
+
+def convert(output_path, tensor_parallel_size, use_te):
+    device = "cuda"
+
+    model_id = "google/paligemma-3b-pt-448"
+    model = PaliGemmaForConditionalGeneration.from_pretrained(model_id).eval()
+
+    model = model.to(device)
+
+    print(model.config)
+    for name, tensor in model.state_dict().items():
+        if "vision_model" not in name:
+            continue
+        shape_str = "(" + ", ".join([str(x) for x in tensor.shape]) + ")"
+        print(f"{name:<75} {shape_str:>20}")
+
+    state_dict = model.state_dict()
+    new_state_dicts = [{"model": dict()} for _ in range(tensor_parallel_size)]
+
+    def add_chunck_tensor(new_tensor, new_name, chunk_dim=None):
+        if chunk_dim is None:
+            new_tensors = [new_tensor for _ in range(tensor_parallel_size)]
+        else:
+            new_tensors = torch.chunk(new_tensor, tensor_parallel_size, dim=chunk_dim)
+
+        for i in range(tensor_parallel_size):
+            # chunk() creates a view of a bigger tensor. clone() is used here to avoid excessive storage.
+            new_state_dicts[i]["model"][new_name] = new_tensors[i].clone()
+
+            # TE sets _extra_state (for FP8 purposes), so set an empty one here for compatibility.
+            extra_state_layers = ("linear_qkv", "linear_proj", "linear_fc1", "linear_fc2")
+            is_extra_state_layer = any([l in new_name for l in extra_state_layers])
+            if use_te and is_extra_state_layer:
+                layer = new_name.split(".")[-2]
+                if layer in extra_state_layers:
+                    extra_state_name = (
+                        new_name[: new_name.rfind(".") + 1] + "_extra_state"
+                    )  # Replace the weight name.
+                    new_state_dicts[i]["model"][extra_state_name] = None
+
+    for name, tensor in state_dict.items():
+        if tensor.dtype == torch.float16:
+            state_dict[name] = tensor.to(torch.float32)
+
+    add_chunck_tensor(
+        state_dict["vision_tower.vision_model.embeddings.position_embedding.weight"],
+        "position_embeddings.weight")
+    add_chunck_tensor(
+        state_dict["vision_tower.vision_model.embeddings.patch_embedding.weight"],
+        "conv1.weight")
+    add_chunck_tensor(
+        state_dict["vision_tower.vision_model.embeddings.patch_embedding.bias"],
+        "conv1.bias")
+
+    head_dim = 72
+    num_head = 16
+    for layer_idx in range(27):
+        origin_base = f"vision_tower.vision_model.encoder.layers.{layer_idx}"
+        target_base = f"decoder.layers.{layer_idx}"
+
+        for param_type in ["weight", "bias"]:
+            # QKV
+            q_proj_params = state_dict[f"{origin_base}.self_attn.q_proj.{param_type}"]
+            k_proj_params = state_dict[f"{origin_base}.self_attn.k_proj.{param_type}"]
+            v_proj_params = state_dict[f"{origin_base}.self_attn.v_proj.{param_type}"]
+            # Do some tensor manipulation because megatron expect one tensor
+            # projection for the QKV in the order
+            # [(Q1, K1, V1), (Q2, K2, V2), ...] where Qi is the query of the
+            # i-th head with dimension num_head.
+            new_tensor = torch.concatenate([
+                q_proj_params.view(num_head, head_dim, -1),
+                k_proj_params.view(num_head, head_dim, -1),
+                v_proj_params.view(num_head, head_dim, -1)], axis=1).view(
+                    3*head_dim*num_head, -1)
+            if param_type == "bias":
+                new_tensor = new_tensor[:, 0]
+            new_name = f"{target_base}.self_attention.linear_qkv.{param_type}"
+            add_chunck_tensor(new_tensor, new_name, chunk_dim=0)
+            # linear_proj
+            add_chunck_tensor(
+                state_dict[f"{origin_base}.self_attn.out_proj.{param_type}"],
+                f"{target_base}.self_attention.linear_proj.{param_type}",
+                chunk_dim=1 if param_type == "weight" else None)
+            # layer_norm
+            new_name = f"{target_base}.input_layernorm.{param_type}"
+            if use_te:
+                new_name = f"{target_base}.self_attention.linear_qkv.layer_norm_{param_type}"
+            add_chunck_tensor(
+                state_dict[f"{origin_base}.layer_norm1.{param_type}"],
+                new_name)
+            # FC 1
+            add_chunck_tensor(
+                state_dict[f"{origin_base}.mlp.fc1.{param_type}"],
+                f"{target_base}.mlp.linear_fc1.{param_type}",
+                chunk_dim=0)
+            # FC 2
+            add_chunck_tensor(
+                state_dict[f"{origin_base}.mlp.fc2.{param_type}"],
+                f"{target_base}.mlp.linear_fc2.{param_type}",
+                chunk_dim=1 if param_type=="weight" else None)
+            # layer_norm
+            new_name = f"{target_base}.pre_mlp_layernorm.{param_type}"
+            if use_te:
+                new_name = f"{target_base}.mlp.linear_fc1.layer_norm_{param_type}"
+            add_chunck_tensor(
+                state_dict[f"{origin_base}.layer_norm2.{param_type}"],
+                new_name)
+
+    add_chunck_tensor(
+        state_dict["vision_tower.vision_model.post_layernorm.weight"],
+        "ln_post.weight")
+    add_chunck_tensor(
+        state_dict["vision_tower.vision_model.post_layernorm.bias"],
+        "ln_post.bias")
+
+    for i in range(tensor_parallel_size):
+        output_dir_tp = os.path.join(output_path, "iter_0000001", f"mp_rank_0{i}")
+        os.makedirs(output_dir_tp)
+        output_path_tp = os.path.join(output_dir_tp, "model_optim_rng.pt")
+        torch.save(new_state_dicts[i], output_path_tp)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="""
+Convert SigLIP weights to megatron format.
+
+
+Example usage:
+python siglip_converter.py --tensor-parallel-size 4 --output google_paligemma_3b_pt_44_mcore_tp_4 --use-te
+
+examples/multimodal/combine_mistral_clip.sh Mistral-7B-Instruct-v0.3-mcore-tp4 google_paligemma_3b_pt_44_mcore_tp_4 mistral_7b_instruct_v0p3_google_paligemma_3b_pt_44_mcore_tp_4
+""",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "--output", type=str, required=True, help="output directory for megatron state dict file(s)"
+    )
+    parser.add_argument(
+        "--tensor-parallel-size", type=int, default=1, help="model tensor parallel size"
+    )
+    parser.add_argument("--use-te", action="store_true", help="Use Transformer Engine")
+
+    args = parser.parse_args()
+
+    convert(args.output, args.tensor_parallel_size, args.use_te)
+
+    print("done.")
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/model_converter/vision_model_tester.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/model_converter/vision_model_tester.py
new file mode 100644
index 0000000000000000000000000000000000000000..ef36dd5f9e0dec4a55274d9aa3dbdeffcd737d40
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/model_converter/vision_model_tester.py
@@ -0,0 +1,121 @@
+# Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved.
+import argparse
+import os
+import sys
+
+# Add megatron and the multimodal example to the path.
+sys.path.append(
+    os.path.abspath(
+        os.path.join(os.path.dirname(__file__), os.path.pardir, os.path.pardir, os.path.pardir)
+    )
+)
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), os.path.pardir)))
+
+import torch
+from transformers import AutoModel
+
+from examples.multimodal.model import model_provider
+from examples.multimodal.multimodal_args import add_multimodal_extra_args
+from megatron.training import get_model
+from megatron.training.checkpointing import load_checkpoint
+from megatron.training.initialize import initialize_megatron
+
+
+def run_mcore_vision(model_path):
+    """Run mcore vision model."""
+    os.environ["CUDA_DEVICE_MAX_CONNECTIONS"] = "1"
+
+    # Megatron has some mandatory flags.
+    sys.argv = [
+        "ignore_me.py",
+        "--micro-batch-size=1",
+        "--num-layers=2",
+        "--vision-model-type=internvit",
+        "--language-model-type=mistral_7b",
+        "--tokenizer-prompt-format=mistral",
+        "--tokenizer-type=MultimodalTokenizer",
+        "--tokenizer-model=mistralai/Mistral-7B-Instruct-v0.3",
+        "--vocab-size=1024",
+        "--hidden-size=64",
+        "--num-attention-heads=8",
+        "--seq-length=1024",
+        "--decoder-seq-length=2048",
+        "--max-position-embeddings=2048",
+        "--bf16",
+        "--img-h=448",
+        "--img-w=448",
+        "--patch-dim=14",
+        "--tensor-model-parallel-size=8",
+        "--use-te",
+        f"--pretrained-checkpoint={model_path}",
+    ]
+
+    initialize_megatron(extra_args_provider=add_multimodal_extra_args)
+
+    def wrapped_model_provider(pre_process, post_process):
+        return model_provider(pre_process, post_process, parallel_output=False)
+
+    # Set up model and load checkpoint.
+    model = get_model(wrapped_model_provider, wrap_with_ddp=False)
+
+    vision_model = model[0].module.vision_model
+
+    load_checkpoint([vision_model], None, None)
+
+    vision_model.eval()
+
+    images = torch.ones((1, 3, 448, 448), dtype=torch.bfloat16, device="cuda")
+
+    output = vision_model(images)
+
+    return output
+
+
+def run_hf_vision(model_name):
+    """Run HF vision model."""
+    model = (
+        AutoModel.from_pretrained(model_name, torch_dtype=torch.bfloat16, trust_remote_code=True)
+        .cuda()
+        .eval()
+    )
+
+    images = torch.ones((1, 3, 448, 448), dtype=torch.bfloat16, device="cuda")
+
+    outputs = model(images, return_dict=True)
+
+    return outputs
+
+
+def main(mcore_model, hf_model):
+    """Compare vision model outputs between mcore and HF given the same fixed input."""
+    mcore = run_mcore_vision(mcore_model)
+
+    if torch.distributed.get_rank() == 0:
+        hf = run_hf_vision(hf_model)
+        hf = hf["last_hidden_state"]
+
+        # Compare logits. Due to different attention implementations and other details,
+        # there will be numerical differences.
+        diff = (mcore - hf).abs()
+        mean_diff = diff.mean().item()
+        max_diff = diff.max().item()
+        print(f"mean diff {mean_diff}, max diff {max_diff}")
+        assert mean_diff < 0.1, "mean output difference is greater than expected"
+        assert max_diff < 50, "max output difference is greater than expected"
+
+        print("lgtm")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Check mcore vision model output vs. HF numerically.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "--mcore-model", type=str, required=True, help="directory for mcore model weights"
+    )
+    parser.add_argument("--hf-model", type=str, required=True, help="Model name in HF")
+
+    args = parser.parse_args()
+
+    main(args.mcore_model, args.hf_model)
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/multimodal_args.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/multimodal_args.py
new file mode 100644
index 0000000000000000000000000000000000000000..885d39d545f2fcc29bd9b096f59ac664f4ce50dd
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/multimodal_args.py
@@ -0,0 +1,93 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+from megatron.core.models.multimodal.llava_model import IMAGE_TOKEN
+
+
+def add_multimodal_extra_args(parser):
+    """Extra arguments."""
+    group = parser.add_argument_group(title='multimodal arguments')
+    group.add_argument('--dataset-config', type=str, default=None)
+    group.add_argument("--prompt-path", type=str, default=None)
+    group.add_argument('--freeze-LM', action='store_true', default=False)
+    group.add_argument('--freeze-ViT', action='store_true', default=False)
+    group.add_argument('--language-model-type', type=str, required=True)
+    group.add_argument('--vision-model-type', type=str, default="clip")
+    group.add_argument("--disable-vision-class-token", action="store_true", default=False)
+    group.add_argument(
+        "--allow-missing-vision-projection-checkpoint", action="store_true", default=False
+    )
+    group.add_argument("--use-te", action="store_true", default=False)
+    group.add_argument(
+        "--dataloader-save", type=str, default=None, help="Energon dataloader state save path"
+    )
+    group.add_argument(
+        "--use-tiling", action="store_true", default=False, help="Use input image tiling"
+    )
+    group.add_argument("--max-num-tiles", type=int, default=1, help="Maximum number of image tiles")
+    group.add_argument(
+        "--use-thumbnail", action="store_true", default=False, help="Add image thumbnail as a tile"
+    )
+    group.add_argument(
+        "--dataloader-seq-length",
+        type=int,
+        help="Make dataloader to produce sequences of specific length.",
+    )
+    group.add_argument(
+        "--num-frames",
+        type=int,
+        default=1,
+        help="Number of frames to regularly sample from the video as input to the model.",
+    )
+    group.add_argument(
+        "--online-evaluation-config", type=str, help="Config file for online evaluation."
+    )
+    group.add_argument(
+        "--special-tokens",
+        nargs="*",
+        default=[IMAGE_TOKEN],
+        help="Special tokens used in the multimodal model",
+    )
+    group.add_argument(
+        "--tokenizer-prompt-format",
+        type=str,
+        choices=["mistral", "llama3", "chatml", "nvlm-yi-34b", "qwen2p0", "qwen2p5", "llama3p1", "nemotron5",
+                 "nemotron5-aligned"],
+        required=True,
+        help="Prompt format to use with the tokenizer.",
+    )
+    group.add_argument("--pixel-shuffle", action="store_true", default=False)
+    group.add_argument(
+        "--image-tag-type",
+        type=str,
+        choices=["nvlm", "internvl", ""],
+        default="",  # Default: Image tag not used.
+        help="Surround image tokens with tags.",
+    )
+    group.add_argument("--use-tile-tags", action="store_true", default=False, help="Use tile tags")
+    group.add_argument(
+        "--packing-buffer-size",
+        type=int,
+        default=None,   # Packing is disabled by default.
+        help="Enable sample packing by setting the buffer size to > 0",
+    )
+    group.add_argument(
+        "--packing-seq-length", type=int, default=0, help="Packing sequence length. Must be > 0 if using packing."
+    )
+    group.add_argument(
+        "--recompute-vision", action="store_true", default=False, help="Enable activation checkpointing in the vision model"
+    )
+    group.add_argument(
+        "--use-loss-scaling", action="store_true", default=False, help="Scale loss based on conversation turn length (in tokens)."
+    )
+    group.add_argument(
+        "--force-system-message", action="store_true", default=False, help="Force a specific system message"
+    )
+    group.add_argument("--eos-id", type=int, help="termination id for MultiModal Tokenizer")
+    group.add_argument(
+        "--use-area-weighted-aspect-ratio", action="store_true", default=False,
+        help=(
+            "When --use-tiling is True, find the aspect ratio to use based on the original ",
+            "image aspect ratio and the area covered by the tiles.")
+    )
+    group.add_argument("--use-mcore-inference", action="store_true", default=False, help="Use the MCore inference API")
+
+    return parser
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/pretrain_dataset.yaml b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/pretrain_dataset.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..f27bccba3000329706f9c0b81c4cb43c4552d025
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/pretrain_dataset.yaml
@@ -0,0 +1,15 @@
+__module__: megatron.energon
+__class__: Metadataset
+splits:
+  train:
+    datasets:
+      - weight: 1.
+        path: <path_to_pretraining_dataset_in_energon_format>
+        subflavors:
+          augmentation: false
+  val:
+    datasets:
+      - weight: 1.
+        path: <path_to_pretraining_dataset_in_energon_format>
+        subflavors:
+          augmentation: false
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/pretrain_mistral_clip.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/pretrain_mistral_clip.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8ed3d0ecc649b2ba37131c4e8c4b8cf3d8907df5
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/pretrain_mistral_clip.sh
@@ -0,0 +1,133 @@
+#!/bin/bash
+# Pretrain a multimodal model.
+
+export NCCL_IB_SL=1
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+MODEL_NAME="mcore-llava-mistral-7b-instruct-clip336-pretraining"
+
+# Check that the user has set an output path for model checkpoints.
+if [[ -z $WORKSPACE ]]; then
+    echo "Please set WORKSPACE for storing your model checkpoints."
+    exit 1
+fi
+
+SOURCE=`pwd`
+OUTPUT_BASE="${WORKSPACE}/output"
+OUTPUT="${OUTPUT_BASE}/${MODEL_NAME}"
+
+FINETUNE_DIR=${OUTPUT}/checkpoints
+LOGS_DIR="${OUTPUT}/logs"
+TENSORBOARD_DIR="${OUTPUT}/tensorboard"
+
+export TRITON_CACHE_DIR="${WORKSPACE}/triton-cache/"
+# The following patch to the Triton cache manager is needed for Triton version <= 3.1
+# export TRITON_CACHE_MANAGER="megatron.core.ssm.triton_cache_manager:ParallelFileCacheManager"
+
+if [[ -z $LOAD_NAME ]]; then
+    echo "Please set LOAD_NAME for input model name."
+    exit 1
+fi
+
+CHECKPOINT_DIR="${WORKSPACE}/${LOAD_NAME}/checkpoints"
+
+DATA_TRAIN="${SOURCE}/examples/multimodal/pretrain_dataset.yaml"
+
+DEBUG=0
+if [[ $DEBUG -eq 1 ]]; then
+    BZ=32
+    NW=2
+    HD=0.0
+    LI=1
+    EXTRA_ARGS=""
+    NONDETERMINISTIC_ATTN=1
+else
+    BZ=256
+    NW=2
+    HD=0.1
+    LI=10
+    EXTRA_ARGS=""
+    NONDETERMINISTIC_ATTN=1
+fi
+
+OPTIONS=" \
+    --apply-layernorm-1p \
+    --attention-softmax-in-fp32 \
+    --use-checkpoint-args \
+    --no-use-tokenizer-model-from-checkpoint-args \
+    --use-distributed-optimizer \
+    --transformer-impl transformer_engine \
+    --use-te \
+    --normalization RMSNorm \
+    --group-query-attention \
+    --num-query-groups 8 \
+    --no-masked-softmax-fusion \
+    --num-workers ${NW} \
+    --exit-duration-in-mins 230 \
+    --use-flash-attn \
+    --untie-embeddings-and-output-weights \
+    --disable-bias-linear \
+    --position-embedding-type rope \
+    --rotary-percent 1.0 \
+    --rotary-base 1000000 \
+    --swiglu \
+    --attention-dropout 0.0 \
+    --hidden-dropout ${HD} \
+    --tensor-model-parallel-size 4 \
+    --pipeline-model-parallel-size 1 \
+    --num-layers 32 \
+    --hidden-size 4096 \
+    --num-attention-heads 32 \
+    --seq-length 576 \
+    --decoder-seq-length 1024 \
+    --max-position-embeddings 4096 \
+    --ffn-hidden-size 14336 \
+    --train-iters 20000 \
+    --micro-batch-size 1 \
+    --global-batch-size ${BZ} \
+    --lr-decay-iters 20000 \
+    --lr-warmup-fraction .01 \
+    --lr 0.00015 \
+    --min-lr 1.0e-5 \
+    --lr-decay-style cosine \
+    --log-interval ${LI} \
+    --eval-iters 10 \
+    --eval-interval 1000 \
+    --tokenizer-type MultimodalTokenizer \
+    --tokenizer-model mistralai/Mistral-7B-Instruct-v0.3 \
+    --tokenizer-prompt-format mistral \
+    --data-path ${DATA_TRAIN} \
+    --prompt-path ${SOURCE}/examples/multimodal/manual_prompts.json \
+    --save-interval 1000 \
+    --save ${FINETUNE_DIR} \
+    --load ${FINETUNE_DIR} \
+    --dataloader-save ${FINETUNE_DIR}/dataloader \
+    --pretrained-checkpoint ${CHECKPOINT_DIR} \
+    --split 100,0,0 \
+    --clip-grad 1.0 \
+    --weight-decay 1e-2 \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.95 \
+    --init-method-std 0.014 \
+    --log-params-norm \
+    --log-num-zeros-in-grad \
+    --bf16 \
+    --eod-mask-loss \
+    --freeze-LM \
+    --freeze-ViT \
+    --patch-dim 14 \
+    --img-h 336 \
+    --img-w 336 \
+    --dataloader-type external \
+    --tensorboard-dir ${TENSORBOARD_DIR} \
+    --language-model-type=mistral_7b \
+    --disable-vision-class-token \
+    ${EXTRA_ARGS} \
+    --distributed-timeout-minutes 60 \
+    --allow-missing-vision-projection-checkpoint \
+    --ckpt-format torch
+"
+
+export NVTE_APPLY_QK_LAYER_SCALING=0
+export NVTE_ALLOW_NONDETERMINISTIC_ALGO=${NONDETERMINISTIC_ATTN}
+
+torchrun --nproc_per_node 8 examples/multimodal/train.py ${OPTIONS}
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/radio/radio_g.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/radio/radio_g.py
new file mode 100644
index 0000000000000000000000000000000000000000..9883d58db61f58a13a2ed4a7fd14aaea66733c22
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/radio/radio_g.py
@@ -0,0 +1,138 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+from functools import partial
+
+import torch
+
+from examples.multimodal.layer_scaling import (
+    LayerScalingTransformerLayer,
+    get_bias_dropout_add_layer_scaling,
+)
+from megatron.core.tensor_parallel.layers import ColumnParallelLinear, RowParallelLinear
+from megatron.core.transformer.attention import SelfAttention, SelfAttentionSubmodules
+from megatron.core.transformer.dot_product_attention import DotProductAttention
+from megatron.core.transformer.enums import AttnMaskType
+from megatron.core.transformer.identity_op import IdentityOp
+from megatron.core.transformer.mlp import MLP, MLPSubmodules
+from megatron.core.transformer.spec_utils import ModuleSpec
+from megatron.core.transformer.transformer_layer import TransformerLayer, TransformerLayerSubmodules
+from megatron.core.typed_torch import not_none
+from megatron.core.extensions.transformer_engine import HAVE_TE
+
+if HAVE_TE:
+    from megatron.core.extensions.transformer_engine import (
+        TEColumnParallelLinear,
+        TEDotProductAttention,
+        TELayerNormColumnParallelLinear,
+        TENorm,
+        TERowParallelLinear,
+    )
+else:
+    (
+        TEColumnParallelLinear,
+        TEDotProductAttention,
+        TELayerNormColumnParallelLinear,
+        TENorm,
+        TERowParallelLinear,
+    ) = (None, None, None, None, None)
+
+try:
+    import apex
+
+    from megatron.core.fusions.fused_layer_norm import FusedLayerNorm
+
+    HAVE_APEX = True
+    LNImpl = FusedLayerNorm
+except ImportError:
+    import warnings
+
+    from megatron.core.transformer.torch_norm import WrappedTorchNorm
+
+    warnings.warn(f'Apex is not installed. Falling back to Torch Norm')
+    LNImpl = WrappedTorchNorm
+
+
+def get_mlp_module_spec(use_te: bool = True) -> ModuleSpec:
+    # Dense MLP w/ or w/o TE modules.
+    return ModuleSpec(
+        module=MLP,
+        submodules=MLPSubmodules(
+            linear_fc1=not_none(TEColumnParallelLinear) if use_te else ColumnParallelLinear,
+            linear_fc2=not_none(TERowParallelLinear) if use_te else RowParallelLinear,
+        ),
+    )
+
+
+def get_norm_mlp_module_spec_te() -> ModuleSpec:
+    return ModuleSpec(
+        module=MLP,
+        submodules=MLPSubmodules(
+            linear_fc1=not_none(TELayerNormColumnParallelLinear),
+            linear_fc2=not_none(TERowParallelLinear),
+        ),
+    )
+
+
+def get_radio_g_layer_spec(normalization) -> ModuleSpec:
+    attn_mask_type = AttnMaskType.no_mask
+    if normalization == "LayerNorm":
+        norm = LNImpl
+    elif normalization == "RMSNorm":
+        if HAVE_TE:
+            norm = TENorm
+        else:
+            assert is_torch_min_version("2.4.0"), "Torch version >= 2.4.0 is required for RMSNorm"
+            if HAVE_APEX:
+                warnings.warn(f'Apex does not support RMSNorm. Falling back to Torch Norm')
+            norm = WrappedTorchNorm
+    else:
+        raise RuntimeError("unknown normalization", normalization)
+
+    mlp = get_mlp_module_spec(use_te=False)  # doesn't include norm.
+
+    return ModuleSpec(
+        module=LayerScalingTransformerLayer,
+        submodules=TransformerLayerSubmodules(
+            input_layernorm=not_none(norm),
+            self_attention=ModuleSpec(
+                module=SelfAttention,
+                params={"attn_mask_type": attn_mask_type},
+                submodules=SelfAttentionSubmodules(
+                    linear_qkv=ColumnParallelLinear,
+                    core_attention=DotProductAttention,
+                    linear_proj=RowParallelLinear,
+                    q_layernorm=IdentityOp,
+                    k_layernorm=IdentityOp,
+                ),
+            ),
+            self_attn_bda=get_bias_dropout_add_layer_scaling,
+            pre_mlp_layernorm=not_none(norm),
+            mlp=mlp,
+            mlp_bda=get_bias_dropout_add_layer_scaling,
+        ),
+    )
+
+
+def get_radio_g_layer_spec_te() -> ModuleSpec:
+    attn_mask_type = AttnMaskType.no_mask
+
+    mlp = get_norm_mlp_module_spec_te()
+    return ModuleSpec(
+        module=LayerScalingTransformerLayer,
+        submodules=TransformerLayerSubmodules(
+            self_attention=ModuleSpec(
+                module=SelfAttention,
+                params={"attn_mask_type": attn_mask_type},
+                submodules=SelfAttentionSubmodules(
+                    linear_qkv=not_none(TELayerNormColumnParallelLinear),
+                    core_attention=not_none(TEDotProductAttention),
+                    linear_proj=TERowParallelLinear,
+                    q_layernorm=IdentityOp,
+                    k_layernorm=IdentityOp,
+                ),
+            ),
+            self_attn_bda=get_bias_dropout_add_layer_scaling,
+            pre_mlp_layernorm=IdentityOp,
+            mlp=mlp,
+            mlp_bda=get_bias_dropout_add_layer_scaling,
+        ),
+    )
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/run_text_generation.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/run_text_generation.py
new file mode 100644
index 0000000000000000000000000000000000000000..e55679c1b2e78a4c90b887cef69207c299ef846b
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/run_text_generation.py
@@ -0,0 +1,869 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+"""Generate text using a vision language model."""
+import json
+import logging
+import os
+import sys
+from functools import partial
+from typing import List, Dict
+
+# Add megatron to the path.
+sys.path.append(
+    os.path.abspath(os.path.join(os.path.dirname(__file__), os.path.pardir, os.path.pardir))
+)
+
+import torch
+import yaml
+from config import EvaluationConfig
+from evaluation.evaluation_datasets import get_evaluation_dataset
+from model import model_provider
+from multimodal_args import add_multimodal_extra_args
+
+from megatron.core import parallel_state
+from megatron.core.enums import ModelType
+from megatron.core.models.multimodal.llava_model import IMAGE_TOKEN
+from megatron.core.models.vision.clip_vit_model import get_num_image_embeddings
+from megatron.inference.text_generation.api import generate_and_post_process
+from megatron.inference.text_generation.forward_step import ForwardStep
+from megatron.core.inference.contexts import StaticInferenceContext
+from megatron.core.inference.sampling_params import SamplingParams
+from megatron.core.inference.engines import StaticInferenceEngine
+from megatron.core.inference.inference_request import InferenceRequest, VLMInferenceRequest
+from megatron.core.inference.text_generation_controllers.vlm_text_generation_controller import (
+    VLMTextGenerationController,
+)
+from megatron.core.inference.model_inference_wrappers.inference_wrapper_config import (
+    InferenceWrapperConfig,
+)
+from megatron.core.inference.model_inference_wrappers.multimodal.vlm_inference_wrapper import (
+    VLMInferenceWrapper,
+)
+from megatron.training import get_args, get_model, get_tokenizer, print_rank_0, is_last_rank
+from megatron.training.checkpointing import load_checkpoint
+from megatron.training.initialize import initialize_megatron
+
+
+def is_first_rank():
+    """First tensor and pipeline parallel rank."""
+    return (
+        parallel_state.is_pipeline_first_stage(ignore_virtual=True)
+        and parallel_state.get_tensor_model_parallel_rank() == 0
+    )
+
+
+def add_text_generation_args(parser):
+    """Text generation arguments."""
+    group = parser.add_argument_group(title='Vision language model text generation arguments')
+
+    group.add_argument("--temperature", type=float, default=1.0, help='Sampling temperature.')
+    group.add_argument("--top_p", type=float, default=0.0, help='Top p sampling.')
+    group.add_argument("--top_k", type=int, default=0, help='Top k sampling.')
+    group.add_argument(
+        "--out-seq-length", type=int, default=128, help='Length of the output generated text.'
+    )
+    group.add_argument("--output-path", type=str, help='Output file path')
+    group.add_argument('--input-image-path', type=str, help="Input image directory")
+    group.add_argument(
+        '--num-partitions', type=int, default=0, help="Number of partitions for inputs."
+    )
+    group.add_argument('--partition-id', type=int, default=0, help="Partition index")
+    group.add_argument("--gt-path", type=str, help="Optional ground truth file")
+    group.add_argument(
+        "--task",
+        type=str,
+        choices=[
+            "captioning",
+            "TextVQA",
+            "VQAv2",
+            "ChartQA",
+            "MMMU",
+            "OCRBench",
+            "OCRBench_v2",
+            "MathVista",
+            "AI2D",
+            "InfoVQA",
+            "SPDocVQA",
+            "RD_TableBench",
+            "VideoMME",
+            "PerceptionTest",
+            "MotionBench",
+            "PhysGameBench",
+            "MVBench",
+            "inference",
+        ],
+        help="Generation task to run",
+    )
+    group.add_argument(
+        "--num-samples-per-partition", type=int, default=0, help="Number of samples per partition"
+    )
+    group.add_argument("--config-path", type=str, help="Evaluation config file to use.")
+
+    # Add common multimodal arguments needed for e.g. building the model.
+    parser = add_multimodal_extra_args(parser)
+
+    return parser
+
+
+def get_evaluation_dataloader(
+    task,
+    input_image_path,
+    gt_path,
+    img_h,
+    img_w,
+    use_tiling,
+    max_num_tiles,
+    use_thumbnail,
+    num_samples_per_partition,
+    num_partitions,
+    partition_id,
+    num_frames,
+    num_workers,
+    vision_model_type,
+    split="validation"
+):
+    """Build evaluation dataset."""
+    dataset = get_evaluation_dataset(
+        task,
+        input_image_path,
+        gt_path,
+        img_h,
+        img_w,
+        use_tiling,
+        max_num_tiles,
+        use_thumbnail,
+        num_samples_per_partition,
+        num_partitions,
+        partition_id,
+        num_frames,
+        vision_model_type,
+        split=split
+    )
+
+    dp_rank = parallel_state.get_data_parallel_rank()
+    dp_world_size = parallel_state.get_data_parallel_world_size()
+
+    sampler = torch.utils.data.DistributedSampler(
+        dataset, shuffle=False, num_replicas=dp_world_size, rank=dp_rank
+    )
+    # TODO: Batched inference is not supported yet.
+    dataloader = torch.utils.data.DataLoader(
+        dataset, batch_size=None, num_workers=num_workers, sampler=sampler, pin_memory=True
+    )
+
+    return dataloader
+
+
+def generate_samples(model, config: EvaluationConfig, print_output):
+    """Text generation using a trained vision language model."""
+    args = get_args()
+
+    dataloader = get_evaluation_dataloader(
+        config.task,
+        config.input_image_path,
+        config.gt_path,
+        args.img_h,
+        args.img_w,
+        args.use_tiling,
+        args.max_num_tiles,
+        args.use_thumbnail,
+        config.num_samples_per_partition,
+        config.num_partitions,
+        config.partition_id,
+        args.num_frames,
+        args.num_workers,
+        args.vision_model_type,
+        config.split
+    )
+
+    num_img_embeddings_per_tile = get_num_image_embeddings(
+        args.img_h,
+        args.img_w,
+        args.patch_dim,
+        args.vision_model_type,
+        args.disable_vision_class_token,
+        1,
+        args.pixel_shuffle,
+        args.use_tile_tags,
+        args.max_num_tiles,
+        args.tokenizer_prompt_format,
+    )
+
+    if args.use_mcore_inference:
+        inference_wrapper_config = InferenceWrapperConfig(
+            hidden_size=args.hidden_size,
+            inference_batch_times_seqlen_threshold=args.inference_batch_times_seqlen_threshold,
+            fp32_residual_connection=args.fp32_residual_connection,
+            params_dtype=args.params_dtype,
+            padded_vocab_size=args.padded_vocab_size,
+        )
+        inference_wrapped_model = VLMInferenceWrapper(model, inference_wrapper_config)
+        tokenizer = get_tokenizer()
+        controller = VLMTextGenerationController(
+            inference_wrapped_model=inference_wrapped_model, tokenizer=tokenizer
+        )
+        inference_engine = StaticInferenceEngine(
+            controller, max_batch_size=1, random_seed=args.seed, legacy=True
+        )
+        sampling_params = SamplingParams(
+            temperature=config.temperature,
+            top_k=config.top_k,
+            top_p=config.top_p,
+            num_tokens_to_generate=config.out_seq_length,
+        )
+
+    for idx, (imgs, num_tiles, sample_id, question, answers, metadata) in enumerate(dataloader):
+        imgs = imgs.to("cuda")
+        num_tiles = num_tiles.to("cuda")
+
+        conv = get_conversation(config.task, question, metadata)
+
+        if not args.use_mcore_inference:
+            forward_step = partial(VLMForwardStep, num_img_embeddings_per_tile, imgs, num_tiles, args.decoder_seq_length)
+
+        inference_context = StaticInferenceContext(max_batch_size=1, max_sequence_length=args.inference_max_seq_length)
+        if is_first_rank():
+
+            if args.use_mcore_inference:
+                inference_request = VLMInferenceRequest(
+                   request_id=inference_engine.get_new_request_id(),
+                   prompt=conv,
+                   prompt_tokens=controller.tokenize_prompt(controller.tokenizer, conv),
+                   sampling_params=sampling_params,
+                   num_img_embeddings_per_tile=num_img_embeddings_per_tile,
+                   imgs=imgs,
+                   num_tiles=num_tiles,
+                   decoder_seq_length=args.decoder_seq_length,
+                )
+                results: List[InferenceRequest] = inference_engine.generate(
+                    inference_requests=[inference_request]
+                )
+
+                resp_sentences = [
+                    tokenizer.detokenize(result.prompt_tokens) + result.generated_text
+                    for result in results
+                ]
+            else:
+                resp_sentences, _, _, _ = generate_and_post_process(
+                    model, inference_context,
+                    forward_step=forward_step,
+                    prompts=[conv],
+                    tokens_to_generate=config.out_seq_length,
+                    top_k_sampling=config.top_k,
+                    top_p_sampling=config.top_p,
+                    add_BOS=False,
+                    temperature=config.temperature,
+                    random_seed=args.seed,
+                    detokenize_segments=False,
+                    data_parallel=True,
+            )
+
+            for generation in resp_sentences:
+                if isinstance(sample_id, torch.Tensor):
+                    sample_id = sample_id.item()
+
+                output = {"sample_id": sample_id}
+
+                output_name = ""
+                if config.task == "captioning":
+                    output_name = "caption"
+                elif config.task in (
+                    "TextVQA",
+                    "VQAv2",
+                    "ChartQA",
+                    "OCRBench",
+                    "MathVista",
+                    "AI2D",
+                    "RealworldQA",
+                    "MotionBench",
+                    "PhysGameBench",
+                    "MVBench",
+                    "InfoVQA",
+                    "SPDocVQA",
+                    "inference",
+                ):
+                    output_name = "answer"
+                elif config.task in ("MMMU"):
+                    output_name = "text"
+                elif config.task == "VideoMME":
+                    output_name = "response"
+                    output = question
+                elif config.task in ["OCRBench_v2", "RD_TableBench"]:
+                    output_name = "predict"
+                else:
+                    raise NotImplementedError("no output name defined for", config.task)
+
+                prompt, generated = get_prompt_and_generated(
+                    generation, args.tokenizer_prompt_format
+                )
+                if config.task == "VideoMME":
+                    output["questions"][0][output_name] = generated
+                else:
+                    output["prompt"] = prompt
+                    output[output_name] = generated
+
+                if config.task in ["captioning", "RD_TableBench"]:
+                    output["ground_truth"] = answers
+                elif config.task in (
+                    "TextVQA",
+                    "VQAv2",
+                    "ChartQA",
+                    "OCRBench",
+                    "OCRBench_v2",
+                    "MathVista",
+                    "AI2D",
+                    "PerceptionTest",
+                    "RealworldQA",
+                    "MotionBench",
+                    "PhysGameBench",
+                    "MVBench",
+                    "InfoVQA",
+                    "SPDocVQA",
+                    "inference",
+                ):
+                    if isinstance(answers, str):
+                        answers = [answers]
+                    output["gt_answer"] = answers
+
+                    if len(metadata) > 0:
+                        output.update(metadata)
+                elif config.task == "MMMU":
+                    output["prediction"] = generated
+                    output.update(metadata)
+                elif config.task == "VideoMME":
+                    pass
+                else:
+                    raise NotImplementedError("no output processing defined for", config.task)
+
+                if print_output:
+                    print(output)
+
+                yield output
+                idx += 1
+        else:
+            if args.use_mcore_inference:
+                inference_request = VLMInferenceRequest(
+                   request_id=inference_engine.get_new_request_id(),
+                   prompt=conv,
+                   prompt_tokens=controller.tokenize_prompt(controller.tokenizer, conv),
+                   sampling_params=sampling_params,
+                   num_img_embeddings_per_tile=num_img_embeddings_per_tile,
+                   imgs=imgs,
+                   num_tiles=num_tiles,
+                   decoder_seq_length=args.decoder_seq_length,
+                )
+                inference_engine.generate(
+                    inference_requests=[inference_request]
+                )
+            else:
+                generate_and_post_process(
+                    model, inference_context, forward_step=forward_step, detokenize_segments=False, data_parallel=True
+                )
+
+            idx += 1
+
+
+def get_evaluation_configs(config_path=None) -> Dict[str, EvaluationConfig]:
+    """Get evaluation config(s) from a config file or command-line arguments.
+
+    Args:
+        config_path: Optional path to config file. If not provided, will check args.config_path
+                    or fall back to command-line arguments.
+
+    Returns:
+        Dict[str, EvaluationConfig]: dict of configs.
+    """
+    args = get_args()
+    configs = {}
+
+    # Use provided config_path or fall back to args.config_path
+    config_file = config_path or args.config_path
+
+    # We check if we're trying to run a single config evals by checking for the task and output_path
+    # args.
+    if hasattr(args, "task") and args.task and hasattr(args, "output_path") and args.output_path:
+        # Single config from args
+        config = EvaluationConfig(
+            task=args.task,
+            temperature=args.temperature,
+            top_p=args.top_p,
+            top_k=args.top_k,
+            out_seq_length=args.out_seq_length,
+            output_path=args.output_path,
+            input_image_path=args.input_image_path,
+            gt_path=args.gt_path,
+            num_partitions=args.num_partitions,
+            partition_id=args.partition_id,
+            num_samples_per_partition=args.num_samples_per_partition,
+        )
+        if not config.output_path:
+            default_output_dir = args.output_path if args.output_path else "generated"
+            os.makedirs(default_output_dir, exist_ok=True)
+            config.output_path = os.path.join(default_output_dir, args.language_model_type)
+        return {args.task: config}
+    elif config_file:
+        with open(config_file, "r") as f:
+            config_data = yaml.safe_load(f)
+        if 'datasets' not in config_data:
+            print("Error: 'datasets' key not found in config file for batch mode.")
+            sys.exit(1)
+        config_dict = config_data['datasets']
+        for key, value in config_dict.items():
+            config = EvaluationConfig(**value)
+            config.dataset = key
+            if not config.output_path:
+                # Use args.output_path if available, otherwise use "generated"
+                default_output_dir = getattr(args, 'output_path', None) or "generated"
+                os.makedirs(default_output_dir, exist_ok=True)
+                config.output_path = os.path.join(default_output_dir, f"{args.language_model_type}")
+            configs[key] = config
+        return configs
+    else:
+        raise ValueError("No config file provided and no task specified.")
+
+
+def get_output_path(config, dp_rank):
+    """Generation output path."""
+
+    ckpt_step = None
+    try:
+        args = get_args()
+        ckpt_step = args.ckpt_step
+    except Exception as e:
+        print(f"Failed getting args: {type(e).__name__} - {e}")
+    if ckpt_step is not None:
+        return f"{config.output_path}-{config.task}-dprank={dp_rank}-partition={config.partition_id}-step={args.ckpt_step}.jsonl"
+    else:
+        return f"{config.output_path}-{config.task}-dprank={dp_rank}-partition={config.partition_id}.jsonl"
+
+
+def generate_and_write_samples(model, config, print_output=True):
+    """Generate text and write to an output file."""
+    dp_rank = parallel_state.get_data_parallel_rank()
+
+    if is_first_rank():
+        output_path = get_output_path(config, dp_rank)
+        output_file = open(output_path, "w")
+        print(f"output path: {output_file.name}")
+
+    with torch.no_grad():
+        for output in generate_samples(model, config, print_output):
+            if is_first_rank():
+                output_file.write(json.dumps(output) + "\n")
+                output_file.flush()
+
+    if is_first_rank():
+        output_file.close()
+
+class VLMForwardStep(ForwardStep):
+    """Inference forward step for a multimodal model."""
+
+    def __init__(
+        self,
+        num_img_embeddings_per_tile,
+        images,
+        num_tiles,
+        decoder_seq_length,
+        model,
+        inference_context,
+    ):
+        """Create multimodal forward step."""
+        total_num_tiles = torch.sum(num_tiles).item()
+        num_img_embeddings = num_img_embeddings_per_tile * total_num_tiles
+
+        super().__init__(model, inference_context)
+        self._images = images
+        self._num_tiles = num_tiles
+        self._num_img_embeddings = num_img_embeddings
+        self.decoder_seq_length = decoder_seq_length
+
+        self._recv_only_vision_embeds = False  # TODO: Implement new logic for vision embeddings
+        self._encoder_only = False  # TODO: Implement new logic for encoder-only stages
+
+    def _forward(self, tokens, position_ids, attention_mask):
+        return self.model(
+            self._images,
+            tokens,
+            position_ids,
+            attention_mask=None,
+            inference_context=self.inference_context,
+            num_image_tiles=self._num_tiles,
+            runtime_gather_output=True,
+        )
+
+    def __call__(self, tokens, position_ids, attention_mask):
+        num_image_tokens = (tokens == self.model.module.image_token_index).sum().item()
+        num_tokens = tokens.size(1)
+        recv_buffer_seq_length = None
+        if num_image_tokens > 0:
+            # When there are image tokens and this stage only receives vision embeddings, adjust the recv buffer seq length to match the image embeddings sequence length.
+            # If there are image tokens and this stage receives full embeddings, make sure we compensate for expansion of image tokens.
+            # Note that this will set a recv_buffer_seq_length for the encoder stage, this length is irrelevant since that recv buffer is never allocated.
+            if self._recv_only_vision_embeds:
+                recv_buffer_seq_length = self._num_img_embeddings
+            else:
+                recv_buffer_seq_length = min(self._num_img_embeddings + num_tokens - num_image_tokens, self.decoder_seq_length)
+        elif self._recv_only_vision_embeds:
+            # If this stage only receives vision embeddings and there are no image tokens we won't run the encoder and therefore shouldn't try to recv.
+            recv_buffer_seq_length = 0
+
+        # If the pipeline stage only has a vision encoder, then it only needs to run when there are image tokens
+        if not (self._encoder_only and num_image_tokens == 0):
+            output = super().__call__(tokens, position_ids, attention_mask, recv_buffer_seq_length=recv_buffer_seq_length)
+        else:
+            output = None
+        if isinstance(output, tuple):
+            logits, _ = output
+        else:
+            logits = output
+
+        # On the first inference iteration, we compute image tokens.
+        # On every PP stage(although inference params should only matter for decoder),
+        # update the sequence length offset by the number of image tokens.
+        if num_tokens > 1 and num_image_tokens > 0:
+            if "image_tokens_count" not in self.inference_context.key_value_memory_dict:
+                self.inference_context.key_value_memory_dict["image_tokens_count"] = self._num_img_embeddings
+
+            if self._num_img_embeddings + num_tokens - num_image_tokens > self.decoder_seq_length:
+                self.inference_context.sequence_len_offset += self.decoder_seq_length - num_tokens
+            else:
+                self.inference_context.sequence_len_offset += (
+                    self.inference_context.key_value_memory_dict["image_tokens_count"] - num_image_tokens
+                )
+
+        return logits
+
+
+def get_conversation(task, question, metadata=None):
+    """Get a conversation for a given task and evaluation question."""
+    conversation = []
+
+    # In all cases, the tokenizer adds possible header tokens for the assistant.
+    if task == "captioning":
+        conversation = [
+            {"role": "system", "content": "Answer the questions."},
+            {
+                "role": "user",
+                "content": f"{IMAGE_TOKEN}\nGive a brief description of this image in one sentence.",
+            },
+        ]
+    elif task in ("TextVQA", "InfoVQA", "SPDocVQA"):
+        conversation = [
+            {"role": "system", "content": "Follow the user's instruction and answer questions."},
+            {
+                "role": "user",
+                "content": f"{IMAGE_TOKEN}\n{question}\nAnswer the question using a single word, phrase, or number.",
+            },
+        ]
+    elif task == "VQAv2":
+        conversation = [
+            {"role": "system", "content": "Follow the user's instruction and answer questions."},
+            {
+                "role": "user",
+                "content": f"{IMAGE_TOKEN}\n{question}\nAnswer the question using a single word or phrase.",
+            },
+        ]
+    elif task == "ChartQA":
+        conversation = [
+            {"role": "system", "content": "Follow the user's instruction and answer questions."},
+            {
+                "role": "user",
+                "content": f"{IMAGE_TOKEN}\n{question}\nAnswer the question using a single word or phrase.",
+            },
+        ]
+    elif task == "MMMU":
+        conversation = [
+            {"role": "system", "content": "Answer the questions."},
+            {"role": "user", "content": f"{IMAGE_TOKEN}\n{question}"},
+        ]
+    elif task == "VideoMME":
+        q = (
+            "Select the best answer to the following multiple-choice "
+            "question based on the video. Respond with only the letter "
+            "(A, B, C, or D) of the correct option.\n"
+        )
+        q += question["questions"][0]["question"] + "\n"
+        q += question["questions"][0]["choices"][0] + "\n"
+        q += question["questions"][0]["choices"][1] + "\n"
+        q += question["questions"][0]["choices"][2] + "\n"
+        q += question["questions"][0]["choices"][3] + "\n"
+
+        conversation = [
+            {"role": "system", "content": "Answer the questions."},
+            {"role": "user", "content": f"{IMAGE_TOKEN}\n{q}"},
+        ]
+    elif task in ("OCRBench", "OCRBench_v2", "RD_TableBench"):
+        conversation = [
+            {"role": "system", "content": "Follow the user's instruction and answer questions."},
+            {"role": "user", "content": f"{IMAGE_TOKEN}\n{question}"},
+        ]
+    elif task == "MathVista":
+        conversation = [
+            {"role": "system", "content": "You are math expert. Use your math knowledge to calculate the answer."},
+            {"role": "user", "content": f"{IMAGE_TOKEN}\n{question}"},
+        ]
+    elif task == "RealworldQA":
+        conversation = [
+            {"role": "system", "content": "Follow the user's instruction and answer questions."},
+            {"role": "user", "content": f"{IMAGE_TOKEN}\n{question}"},
+        ]
+    elif task == "AI2D":
+        conversation = [
+            {"role": "system", "content": "Follow the user's instruction and answer questions."},
+            {"role": "user", "content": f"{IMAGE_TOKEN}\n{question}"},
+        ]
+    elif task == "MotionBench":
+        extra_instruction = "Respond with only the letter choice (A, B, C, or D) of the correct option.\n"
+        conversation = [
+            {"role": "system", "content": "Answer the questions."},
+            {"role": "user", "content": f"{IMAGE_TOKEN}\n{question}\n{extra_instruction}"},
+        ]
+    elif task == "PhysGameBench":
+        extra_instruction = "Respond with only the letter choice (A, B, C, or D) of the correct option.\n"
+        conversation = [
+            {"role": "system", "content": "Answer the questions."},
+            {"role": "user", "content": f"{IMAGE_TOKEN}\n{question}\n{extra_instruction}"},
+        ]
+    elif task == "MVBench":
+        conversation = [
+            {"role": "system", "content": "Answer the questions."},
+            {"role": "user", "content": f"{IMAGE_TOKEN}\n{question}\nAnswer the question using a single word or phrase."},
+        ]
+    elif task in ["PerceptionTest"]:
+        conversation = [
+            {"role": "system", "content": "Answer the questions."},
+            {"role": "user", "content": f"{IMAGE_TOKEN}\n{question}"},
+        ]
+    elif task == "inference":
+        conversation = [
+            {"role": "system", "content": "Answer the questions."},
+            {"role": "user", "content": f"{question}"},
+        ]
+    else:
+        raise NotImplementedError(f"No prompting support for task {task}")
+
+
+    return conversation
+
+
+def get_prompt_and_generated(prompt_and_generation, prompt_format):
+    """Strip prompt and other unnecessary text from generation."""
+    if prompt_format in ("llama3", "llama3p1"):
+        splitted = prompt_and_generation.split("<|start_header_id|>assistant<|end_header_id|>\n\n")
+        prompt = splitted[0]
+        generated = splitted[1]
+        generated = generated.split("<|eot_id|>")[0]
+    elif prompt_format == "mistral":
+        splitted = prompt_and_generation.split("[/INST]")
+        prompt = splitted[0]
+        generated = splitted[1]
+        generated = generated.split("</s>")[0]
+    elif prompt_format == "chatml":
+        splitted = prompt_and_generation.split("<|im_start|> assistant\n")
+        prompt = splitted[0]
+        generated = splitted[1]
+        generated = generated.split("<|im_end|>")[0]
+    elif prompt_format in ("nvlm-yi-34b", "qwen2p0", "qwen2p5"):
+        splitted = prompt_and_generation.split("<|im_start|>assistant\n")
+        prompt = splitted[0]
+        generated = splitted[1]
+        generated = generated.split("<|im_end|>")[0]
+    elif prompt_format in ("nemotron5"):
+        splitted = prompt_and_generation.split("<SPECIAL_14>assistant\n")
+        prompt = splitted[0]
+        generated = splitted[1]
+        generated = generated.split("<SPECIAL_15>")[0]
+    elif prompt_format in ("nemotron5-aligned"):
+        splitted = prompt_and_generation.split("Assistant\n")
+        prompt = splitted[0]
+        generated = splitted[1]
+        generated = generated.split("[PREFIX]")[0]
+        generated = generated.split("\\n")[0]
+    else:
+        raise ValueError(f"Prompt format {prompt_format} is not supported.")
+
+    # Remove possible garbage.
+    generated = generated.strip()
+
+    return prompt, generated
+
+
+def run_eval(config, iteration=None):
+    # Run evaluation.
+    print(f"====== {config.task} {config.dataset} at iteration={iteration} scores ======")
+
+    if config.task == "TextVQA":
+        from evaluation.evaluate_textvqa import textvqa_eval
+        avg_acc = textvqa_eval(config.output_path)
+
+        score = {"TextVQA accuracy": avg_acc}
+        with open(config.output_path + "-scores.txt", "a") as f:
+            f.write(f"{config.task} {config.dataset} at iteration={iteration} TextVQA accuracy: {score}\n")
+
+    elif config.task == "OCRBench":
+        from evaluation.evaluate_ocrbench import ocrbench_eval
+        log, avg_acc = ocrbench_eval(config.output_path)
+
+        score = {"OCRBench accuracy": avg_acc}
+        with open(config.output_path + "-scores.txt", "a") as f:
+            f.write(f"{config.task} {config.dataset} at iteration={iteration} OCRBench accuracy: {score}\n")
+            f.write(f"{log}\n")
+
+    elif config.task == "MathVista":
+        from evaluation.evaluate_mathvista import mathvista_eval
+        avg_acc = mathvista_eval(config.output_path)
+
+        score = {"MathVista accuracy": avg_acc}
+        with open(config.output_path + "-scores.txt", "a") as f:
+            f.write(f"{config.task} {config.dataset} at iteration={iteration} MathVista accuracy: {score}\n")
+
+    elif config.task == "ChartQA":
+        from evaluation.evaluate_chartqa import chartqa_eval
+        avg_acc = chartqa_eval(config.output_path)
+
+        score = {"ChartQA accuracy": avg_acc}
+        with open(config.output_path + "-scores.txt", "a") as f:
+            f.write(f"{config.task} {config.dataset} at iteration={iteration} ChartQA accuracy: {score}\n")
+
+    elif config.task == "SPDocVQA":
+        from evaluation.evaluate_spdocvqa import spdocvqa_eval
+        avg_acc = spdocvqa_eval(config.output_path)
+
+        score = {"SPDocVQA accuracy": avg_acc}
+        with open(config.output_path + "-scores.txt", "a") as f:
+            f.write(f"{config.task} {config.dataset} at iteration={iteration} SPDocVQA accuracy: {score}\n")
+
+    elif config.task == "RealworldQA":
+        from evaluation.evaluate_realworldqa import realworldqa_eval
+        avg_acc = realworldqa_eval(config.output_path)
+
+        score = {"RealworldQA accuracy": avg_acc}
+        with open(config.output_path + "-scores.txt", "a") as f:
+            f.write(f"{config.task} {config.dataset} at iteration={iteration} RealworldQA accuracy: {score}\n")
+
+    elif config.task == "AI2D":
+        from evaluation.evaluate_ai2d import ai2d_eval
+        avg_acc = ai2d_eval(config.output_path)
+
+        score = {f"AI2D {config.dataset} accuracy": avg_acc}
+        with open(config.output_path + "-scores.txt", "a") as f:
+            f.write(f"{config.task} {config.dataset} at iteration={iteration} AI2D accuracy: {score}\n")
+
+    elif config.task == "MMMU":
+        from evaluation.evaluate_mmmu import convert_to_mmmu_format
+        from examples.multimodal.evaluation.mmmu_utils import mmmu_main_eval
+        result_file = convert_to_mmmu_format(config.output_path)
+        result = json.load(open(result_file))
+        mmmu_results = mmmu_main_eval(result, {"answer_dict": config.gt_path})
+        with open(config.output_path + "-scores.txt", "a") as f:
+            f.write(f"{config.task} {config.split} at iteration={iteration} :\n")
+            for cat, cat_val in mmmu_results.items():
+                if 'Overall' in cat:
+                    cat = cat.replace("Overall-", "")
+                    print(f'{cat}: {cat_val["acc"] * 100:.2f}')
+                    f.write(f'{cat}: {cat_val["acc"] * 100:.2f}\n')
+
+        score = {"MMMU val accuracy": mmmu_results['Overall']['acc']}
+    elif config.task == 'captioning':
+        from evaluation.evaluate_coco import coco_captioning_eval
+        cider_score = coco_captioning_eval(config.output_path, config.gt_path)
+        score = {f"{config.task} {config.dataset} CIDEr": cider_score}
+
+        with open(config.output_path + "-scores.txt", "a") as f:
+            f.write(f"{config.task} {config.dataset} CIDEr scores at iteration={iteration}: {cider_score}\n")
+    elif config.task == 'MotionBench':
+        from evaluation.evaluate_video_motionbench import motionbench_eval
+        avg_acc = motionbench_eval(config.output_path)
+
+        score = {f"MotionBench accuracy": avg_acc}
+        with open(config.output_path + "-scores.txt", "a") as f:
+            f.write(f"{config.task} {config.dataset} scores at iteration={iteration}: {score}\n")
+    elif config.task == 'PhysGameBench':
+        from evaluation.evaluate_video_phys_game_bench import phys_game_bench_eval
+        avg_acc_dict = phys_game_bench_eval(config.output_path)
+
+        score = {f"PhysGame Total accuracy": avg_acc_dict['Physgame-Total-Acc']}
+        with open(config.output_path + "-scores.txt", "a") as f:
+            f.write(f"{config.task} {config.dataset} scores at iteration={iteration}: {avg_acc_dict}\n")
+    elif config.task == "MVBench":
+        from evaluation.evaluate_video_mvbench import mvbench_eval
+        avg_acc_dict = mvbench_eval(config.output_path)
+
+        score = {f"MVBench accuracy": avg_acc_dict['total-acc']}
+        with open(config.output_path + "-scores.txt", "a") as f:
+            f.write(f"{config.task} {config.dataset} scores at iteration={iteration}: {avg_acc_dict}\n")
+    elif config.task == "inference":
+        score = {"Inference accuracy:": None}
+        pass
+    else:
+        raise NotImplementedError(f"Evaluation of {config.task} not implemented yet")
+
+    print(score)
+    return score
+
+
+def run_evaluation_loop(model, configs, output_dir_override=None, iteration=None, print_output=True):
+    """
+    Common evaluation loop used by both online evaluation during training and standalone evaluation.
+
+    Args:
+        model: The model to evaluate
+        configs: Dict[str, EvaluationConfig] - dictionary of evaluation configs
+        output_dir_override: Optional directory to override the output path in configs
+        iteration: Optional iteration number for logging
+        print_output: Whether to print generation output
+
+    Returns:
+        Dict[str, float]: Dictionary of evaluation scores
+    """
+    args = get_args()
+    scores = {}
+
+    for key, config in configs.items():
+        # Handle output path override for online evaluation
+        if output_dir_override:
+            config.output_path = os.path.join(output_dir_override, args.language_model_type)
+
+        # Generate samples and write to file
+        generate_and_write_samples(model, config, print_output=print_output)
+
+        # Synchronize before evaluation
+        torch.distributed.barrier()
+
+        # Run evaluation on the last rank
+        if is_last_rank():
+            task_scores = run_eval(config, iteration=iteration)
+            scores.update(task_scores)
+
+        # Synchronize after evaluation
+        torch.distributed.barrier()
+
+    return scores
+
+
+def eval_tasks():
+    """Vision language model text generation for single or batch tasks."""
+    initialize_megatron(extra_args_provider=add_text_generation_args)
+
+    args = get_args()
+
+    def wrapped_model_provider(pre_process, post_process, add_encoder=True, add_decoder=True):
+        return model_provider(pre_process, post_process, add_encoder=add_encoder, add_decoder=add_decoder,
+                              parallel_output=False)
+
+    # Set up model and load checkpoint.
+    model = get_model(wrapped_model_provider, model_type=ModelType.encoder_or_decoder, wrap_with_ddp=False)
+
+    if args.load is not None:
+        _ = load_checkpoint(model, None, None)
+
+    model = model[0]
+    model.eval()
+
+    configs = get_evaluation_configs()
+
+    # Use the common evaluation loop
+    run_evaluation_loop(model, configs, iteration=args.ckpt_step)
+
+
+if __name__ == "__main__":
+    eval_tasks()
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/sft_dataset.yaml b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/sft_dataset.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..c9f0257ae7111093440d21797ee29218be3f3d52
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/sft_dataset.yaml
@@ -0,0 +1,15 @@
+__module__: megatron.energon
+__class__: Metadataset
+splits:
+  train:
+    datasets:
+      - weight: 1.
+        path: <path_to_sft_dataset_in_energon_format>
+        subflavors:
+          augmentation: false
+  val:
+    datasets:
+      - weight: 1.
+        path: <path_to_sft_dataset_in_energon_format>
+        subflavors:
+          augmentation: false
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/sft_mistral_clip.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/sft_mistral_clip.sh
new file mode 100644
index 0000000000000000000000000000000000000000..6aac68216629847c8d6fd4aed1a6be54c3c92f3d
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/sft_mistral_clip.sh
@@ -0,0 +1,134 @@
+#!/bin/bash
+# Run SFT on a pretrained multimodal model
+
+export NCCL_IB_SL=1
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+MODEL_NAME="mcore-llava-mistral-7b-instruct-clip336-sft"
+
+# Check that the user has set an output path for model checkpoints.
+if [[ -z $WORKSPACE ]]; then
+    echo "Please set WORKSPACE for storing your model checkpoints."
+    exit 1
+fi
+
+SOURCE=`pwd`
+OUTPUT_BASE="${WORKSPACE}/output"
+OUTPUT="${OUTPUT_BASE}/${MODEL_NAME}"
+
+FINETUNE_DIR=${OUTPUT}/checkpoints
+LOGS_DIR="${OUTPUT}/logs"
+TENSORBOARD_DIR="${OUTPUT}/tensorboard"
+
+export TRITON_CACHE_DIR="${WORKSPACE}/triton-cache/"
+# The following patch to the Triton cache manager is needed for Triton version <= 3.1
+export TRITON_CACHE_MANAGER="megatron.core.ssm.triton_cache_manager:ParallelFileCacheManager"
+
+if [[ -z $LOAD_NAME ]]; then
+    echo "Please set LOAD_NAME for input model name."
+    exit 1
+fi
+
+if [[ -z $LOAD_ITER ]]; then
+    echo "Please set LOAD_ITER for pre-trained input model iteration."
+    exit 1
+fi
+
+CHECKPOINT_DIR="${WORKSPACE}/${LOAD_NAME}/checkpoints"
+
+DATA_TRAIN="${SOURCE}/examples/multimodal/sft_dataset.yaml"
+
+DEBUG=0
+if [[ $DEBUG -eq 1 ]]; then
+    BZ=8
+    NW=1
+    HD=0.0
+    LI=1
+    EXTRA_ARGS=""
+    NONDETERMINISTIC_ATTN=1
+else
+    BZ=128
+    NW=2
+    HD=0.1
+    LI=10
+    EXTRA_ARGS=""
+    NONDETERMINISTIC_ATTN=1
+fi
+
+OPTIONS=" \
+    --apply-layernorm-1p \
+    --attention-softmax-in-fp32 \
+    --use-checkpoint-args \
+    --use-distributed-optimizer \
+    --transformer-impl transformer_engine \
+    --use-te \
+    --normalization RMSNorm \
+    --group-query-attention \
+    --num-query-groups 8 \
+    --no-masked-softmax-fusion \
+    --num-workers ${NW} \
+    --exit-duration-in-mins 230 \
+    --use-flash-attn \
+    --untie-embeddings-and-output-weights \
+    --disable-bias-linear \
+    --position-embedding-type rope \
+    --rotary-percent 1.0 \
+    --rotary-base 1000000 \
+    --swiglu \
+    --attention-dropout 0.0 \
+    --hidden-dropout ${HD} \
+    --tensor-model-parallel-size 4 \
+    --pipeline-model-parallel-size 1 \
+    --num-layers 32 \
+    --hidden-size 4096 \
+    --num-attention-heads 32 \
+    --seq-length 576 \
+    --decoder-seq-length 2048 \
+    --max-position-embeddings 4096 \
+    --ffn-hidden-size 14336 \
+    --train-iters 20000 \
+    --micro-batch-size 1 \
+    --global-batch-size ${BZ} \
+    --lr-decay-iters 20000 \
+    --lr-warmup-fraction .01 \
+    --lr 1e-6 \
+    --min-lr 1e-7 \
+    --lr-decay-style cosine \
+    --log-interval ${LI} \
+    --eval-iters 10 \
+    --eval-interval 500 \
+    --tokenizer-type MultimodalTokenizer \
+    --tokenizer-model mistralai/Mistral-7B-Instruct-v0.3 \
+    --tokenizer-prompt-format mistral \
+    --data-path ${DATA_TRAIN} \
+    --prompt-path ${SOURCE}/examples/multimodal/manual_prompts.json \
+    --save-interval 500 \
+    --save ${FINETUNE_DIR} \
+    --load ${FINETUNE_DIR} \
+    --pretrained-checkpoint ${CHECKPOINT_DIR} \
+    --dataloader-save ${FINETUNE_DIR}/dataloader \
+    --split 100,0,0 \
+    --clip-grad 0.5 \
+    --weight-decay 0.1 \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.95 \
+    --init-method-std 0.014 \
+    --log-params-norm \
+    --log-num-zeros-in-grad \
+    --eod-mask-loss \
+    --freeze-ViT \
+    --patch-dim 14 \
+    --img-h 336 \
+    --img-w 336 \
+    --dataloader-type external \
+    --tensorboard-dir ${TENSORBOARD_DIR} \
+    --language-model-type=mistral_7b \
+    --disable-vision-class-token \
+    ${EXTRA_ARGS} \
+    --distributed-timeout-minutes 60 \
+    --ckpt-format torch
+"
+
+export NVTE_APPLY_QK_LAYER_SCALING=0
+export NVTE_ALLOW_NONDETERMINISTIC_ALGO=${NONDETERMINISTIC_ATTN}
+
+torchrun --nproc_per_node 8 examples/multimodal/train.py ${OPTIONS}
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/text_generation_mistral_clip.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/text_generation_mistral_clip.sh
new file mode 100644
index 0000000000000000000000000000000000000000..c1ef7bcee897812fef976531e2a5bba961141b42
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/text_generation_mistral_clip.sh
@@ -0,0 +1,109 @@
+#!/bin/bash
+
+export NCCL_IB_SL=1
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NVTE_APPLY_QK_LAYER_SCALING=0
+
+INPUT_IMAGE_PATH="placeholder"
+GROUNDTRUTH_PATH="placeholder"
+NUM_FRAMES=1
+
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        -i|--input-image-path)
+            INPUT_IMAGE_PATH="$2"
+            shift
+            shift
+            ;;
+        --num-frames)
+            NUM_FRAMES="$2"
+            shift
+            shift
+            ;;
+        -o|--output-path)
+            OUTPUT_PATH="$2"
+            shift
+            shift
+            ;;
+        -m|--model-path)
+            MODEL_PATH="$2"
+            shift
+            shift
+            ;;
+        -t|--task)
+            TASK="$2"
+            shift
+            shift
+            ;;
+        -g|--gt-path)
+            GROUNDTRUTH_PATH="$2"
+            shift
+            shift
+            ;;
+        -*|--*)
+            echo "Invalid option $1"
+            exit 1
+            ;;
+    esac
+done
+
+# Please modify these as needed.
+NUM_PARTITIONS=0
+START=0
+END=0
+
+for PARTITION_ID in $( eval echo {$START..$END} )
+do
+    torchrun --nproc_per_node 8 examples/multimodal/run_text_generation.py \
+        --apply-layernorm-1p \
+        --attention-softmax-in-fp32 \
+        --use-flash-attn \
+        --transformer-impl transformer_engine \
+        --use-te \
+        --use-checkpoint-args \
+        --normalization RMSNorm \
+        --language-model-type mistral_7b \
+        --untie-embeddings-and-output-weights \
+        --disable-bias-linear \
+        --position-embedding-type rope \
+        --rotary-percent 1.0 \
+        --rotary-base 1000000 \
+        --swiglu \
+        --attention-dropout 0.0 \
+        --hidden-dropout 0.0 \
+        --tensor-model-parallel-size 4 \
+        --pipeline-model-parallel-size 1 \
+        --group-query-attention \
+        --num-query-groups 8 \
+        --num-layers 32 \
+        --hidden-size 4096 \
+        --ffn-hidden-size 14336 \
+        --num-attention-heads 32 \
+        --max-position-embeddings 4096 \
+        --no-masked-softmax-fusion \
+        --load ${MODEL_PATH} \
+        --tokenizer-type MultimodalTokenizer \
+        --tokenizer-model mistralai/Mistral-7B-Instruct-v0.3 \
+        --tokenizer-prompt-format mistral \
+        --bf16 \
+        --micro-batch-size 1 \
+        --seq-length 2048 \
+        --out-seq-length 12 \
+        --temperature 1.0 \
+        --img-h 336 \
+        --img-w 336 \
+        --patch-dim 14 \
+        --seed 153 \
+        --top_k 1 \
+        --no-load-rng \
+        --no-load-optim \
+        --input-image-path ${INPUT_IMAGE_PATH} \
+        --num-partitions ${NUM_PARTITIONS} \
+        --partition-id ${PARTITION_ID} \
+        --output-path ${OUTPUT_PATH} \
+        --gt-path ${GROUNDTRUTH_PATH} \
+        --task ${TASK} \
+        --disable-vision-class-token \
+        --num-frames ${NUM_FRAMES} \
+        --ckpt-format torch
+done
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/train.py b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/train.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba49e660445cbf1c3289c82b72951f8f71e7f59f
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/multimodal/train.py
@@ -0,0 +1,395 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+"""Pretrain or SFT multimodal."""
+import math
+import os
+import sys
+from functools import partial
+
+import torch
+import yaml
+
+sys.path.append(
+    os.path.abspath(os.path.join(os.path.dirname(__file__), os.path.pardir, os.path.pardir))
+)
+
+from dataloader_provider import train_valid_test_dataloaders_provider, is_first_or_last_stage
+from model import model_provider
+from multimodal_args import add_multimodal_extra_args
+
+from megatron.core import mpu, tensor_parallel
+from megatron.core.enums import ModelType
+from megatron.core.models.multimodal import context_parallel
+from megatron.core.models.multimodal.llava_model import IGNORE_INDEX, LLaVAModel
+from megatron.core.packed_seq_params import PackedSeqParams
+from megatron.core.parallel_state import (
+    get_tensor_model_parallel_rank,
+    get_pipeline_model_parallel_world_size,
+    is_pipeline_last_stage,
+)
+from megatron.training import get_args, get_timers, get_tokenizer, pretrain
+from megatron.training.utils import is_last_rank, get_batch_on_this_cp_rank
+
+
+def get_batch(data_iterator, image_token_index, img_seq_len):
+    """Generate a batch
+
+    Note: attn_mask_type in layer_specs.py sets the attention mask. Attention mask is None here.
+    """
+    imgs = None
+    tokens = None
+    labels = None
+    loss_mask = None
+    attention_mask = None
+    position_ids = None
+    num_tiles = None
+    packed_seq_params = None
+
+    args = get_args()
+
+    # Dataloader doesn't run on the middle stages in a pipeline parallel model.
+    pp_size = get_pipeline_model_parallel_world_size()
+    if not is_first_or_last_stage(pp_size):
+        # Note these are all set to None above.
+        return tokens, labels, loss_mask, attention_mask, position_ids, imgs, num_tiles, packed_seq_params
+
+    # Broadcast data.
+    torch.cuda.nvtx.range_push("get_data")
+    if data_iterator is not None and get_tensor_model_parallel_rank() == 0:
+        data = next(data_iterator)
+    else:
+        data = None
+
+    data_text = tensor_parallel.broadcast_data(["tokens"], data, torch.int64)["tokens"]
+    labels = tensor_parallel.broadcast_data(["labels"], data, torch.int64)["labels"]
+
+    imgs = tensor_parallel.broadcast_data(["imgs"], data, torch.float32)["imgs"]
+    num_tiles = tensor_parallel.broadcast_data(["num_tiles"], data, torch.int32)["num_tiles"]
+
+    cu_lengths = tensor_parallel.broadcast_data(["cu_lengths"], data, torch.int32)["cu_lengths"]
+    max_lengths = tensor_parallel.broadcast_data(["max_lengths"], data, torch.int32)["max_lengths"]
+
+    # No image input (text-only sample) if the dataloader returned a size 1 image.
+    if imgs.shape == torch.Size([1, 1]):
+        # FSDP can hang with text-only samples. A workaround is to run a valid dummy image through the vision
+        # model and then add image embeddings with a zero multiplier.
+        if args.use_torch_fsdp2:
+            imgs = torch.zeros((1, 3, args.img_h, args.img_w), dtype=torch.float32, device=data_text.device)
+            num_tiles = torch.tensor([], dtype=torch.int, device=data_text.device)
+        else:
+            # Similar workaround is not needed without FSDP and we can use an empty image.
+            # FIXME: text-only data can cause still cause a hang in the special case where
+            # the vision model is own its own pipeline rank and --freeze-ViT is enabled.
+            imgs = torch.tensor([], dtype=torch.float32, device=data_text.device)
+            num_tiles = torch.tensor([], dtype=torch.int, device=data_text.device)
+
+    # Last pipeline parallel stage doesn't need images.
+    if pp_size > 1 and is_pipeline_last_stage():
+        imgs = None
+
+    # If cu_lengths and max_lengths are non-dummy, construct PackedSeqParams. Otherwise, leave it at None.
+    if cu_lengths.shape != torch.Size([1, 1]):
+        assert (
+            cu_lengths.shape[0] == max_lengths.shape[0] == 1
+        ), "micro-batch-size must be 1 for packing"
+        cu_lengths = cu_lengths[0]
+        max_lengths = max_lengths[0]
+
+        packed_seq_params = PackedSeqParams(
+            qkv_format="thd",
+            cu_seqlens_q=cu_lengths,
+            cu_seqlens_kv=cu_lengths,
+            max_seqlen_q=max_lengths,
+            max_seqlen_kv=max_lengths,
+        )
+
+    torch.cuda.nvtx.range_pop()
+
+    tokens_ = data_text.long()
+
+    torch.cuda.nvtx.range_push("index tokens")
+    tokenizer = get_tokenizer()
+    text_length = tokens_.shape[1]
+    tokens = tokens_[:, :text_length].contiguous()
+    labels = labels[:, 1 : text_length + 1].contiguous()
+
+    assert tokens.shape == labels.shape, f"tokens: {tokens.shape} != labels: {labels.shape}"
+    torch.cuda.nvtx.range_pop()
+
+    torch.cuda.nvtx.range_push("get_ltor_masks_and_position_ids")
+    loss_mask, position_ids = get_ltor_masks_and_position_ids(tokens, labels, tokenizer.pad)
+    torch.cuda.nvtx.range_pop()
+
+    # If context parallel is enabled, must shard inputs to CP ranks.
+    if args.context_parallel_size > 1 or args.sequence_parallel:
+        assert tokens.shape[0], "micro-batch-size > 1 not supported yet with CP"
+
+        num_image_tokens = torch.sum(tokens == image_token_index).item()
+        num_image_embeddings = img_seq_len * imgs.shape[0] - num_image_tokens
+        seq_len = text_length + num_image_embeddings
+
+        # CP expects sequence length is divisible by CP size so apply padding.
+        mp_padding_needed = context_parallel.get_padding(
+            seq_len, args.context_parallel_size,
+            args.tensor_model_parallel_size, args.sequence_parallel,
+        )
+        tokens, position_ids, labels, loss_mask = [torch.nn.functional.pad(item, (0, mp_padding_needed)) for item in (tokens, position_ids, labels, loss_mask)]
+
+        # Get PackedSeqParams that indicate the amount of padding for TransformerEngine.
+        packed_seq_params = context_parallel.get_packed_seq_params(tokens, num_image_embeddings, mp_padding_needed, args.context_parallel_size, True)
+
+    return (
+        tokens,
+        labels,
+        loss_mask,
+        attention_mask,
+        position_ids,
+        imgs,
+        num_tiles,
+        packed_seq_params,
+    )
+
+
+def get_ltor_masks_and_position_ids(input_ids, target, pad_token):
+    """Build masks and position id for left to right model."""
+    seq_length = input_ids.shape[1]
+
+    # Position ids.
+    position_ids = torch.arange(seq_length, dtype=torch.long, device=input_ids.device)
+    position_ids = position_ids.unsqueeze(0).expand_as(input_ids)
+
+    # Loss mask.
+    loss_mask = torch.ones(target.size(), dtype=torch.float, device=input_ids.device)
+    loss_mask[target == pad_token] = 0.0  # mask paddings
+    loss_mask[target == IGNORE_INDEX] = 0.0  # mask prompts
+
+    return loss_mask, position_ids
+
+
+def get_mask_start_and_end_idx(arr):
+    """
+    Returns a list of tuples holding the start and end index in arr of the non-zeros contiguuous
+    sub arrays.
+
+    For instance, if arr = [0, 1, 0, 0, 1, 1]
+    get_mask_start_and_end_idx(arr) = [(1, 1), (4, 5)]
+    such that arr[1:1+1] = [1] and arr[4:5+1] = [1, 1]
+    """
+    mask = (arr != 0)
+
+    mask_int = mask.int()
+
+    diff = mask_int[1:] - mask_int[:-1]
+    start_indices = (diff == 1).nonzero(as_tuple=False).flatten() + 1
+    end_indices = (diff == -1).nonzero(as_tuple=False).flatten()
+    if len(mask)==0: return []
+    if mask[0]:
+        start_indices = torch.cat((torch.tensor([0], device=arr.device), start_indices))
+    if mask[-1]:
+        end_indices = torch.cat((end_indices, torch.tensor([len(arr) - 1], device=arr.device)))
+    sequences = list(zip(start_indices.tolist(), end_indices.tolist()))
+    return sequences
+
+
+def scaled_loss_func(loss_mask, output_tensor):
+    """
+    Scaled loss function
+
+    Scale the loss for each conversation turn using the formula:
+
+    1 / sum_j[ sqrt(length(loss_turn_j)) ] * sum_i[ sum(loss_turn_i) / sqrt(length(loss_turn_i)) ]
+
+    Where we use the loss mask to infer the start / end of the conversation turns.
+    """
+    args = get_args()
+    losses = output_tensor.float()
+
+    loss_list = []
+    num_valid_labels_list = []
+    for idx in range(losses.shape[0]):
+        loss_this_sample = losses[idx]
+        turn_start_end_list = get_mask_start_and_end_idx(loss_mask[idx])
+        for turn_start, turn_end in turn_start_end_list:
+            # compute loss for each turn
+            loss_this_turn = loss_this_sample[turn_start:turn_end+1].sum()
+            assert (1 - loss_mask)[idx][turn_start:turn_end+1].sum() < 1.0
+            num_valid_labels_this_turn = turn_end - turn_start + 1
+            loss_this_turn = loss_this_turn / num_valid_labels_this_turn
+            loss_list.append(loss_this_turn)
+            # append num of valid labels for each turn
+            num_valid_labels_list.append(num_valid_labels_this_turn)
+    base_num = sum([math.sqrt(each) for each in num_valid_labels_list])
+    for idx in range(len(loss_list)):
+        # normalize loss for each turn
+        loss_list[idx] = loss_list[idx] * math.sqrt(num_valid_labels_list[idx]) / base_num
+
+    # Some ranks may not get loss tokens due to Context Parallel Sharding
+    if len(loss_list) > 0:
+        total_loss = torch.stack(loss_list).sum()
+        total_tokens = torch.ones_like(total_loss)
+    elif len(loss_list) == 0 and args.context_parallel_size > 1:
+        total_tokens = loss_mask.sum()
+        total_loss = torch.sum(losses.view(-1) * loss_mask)
+    else:
+        raise RuntimeError("loss_list for loss scaling per conversation unexpectedly got empty list")
+
+    num_tokens = total_tokens.clone().detach().to(torch.int)
+    reporting_loss = torch.cat([total_loss.clone().detach().view(1), num_tokens.view(1)])
+
+    return (total_loss, num_tokens, {'lm loss': reporting_loss})
+
+
+def loss_func(loss_mask, output_tensor):
+    args = get_args()
+
+    losses = output_tensor.view(-1).float()
+    loss_mask = loss_mask.contiguous().view(-1).float()
+    loss = torch.sum(losses * loss_mask)
+
+    num_tokens = loss_mask.sum().clone().detach().to(torch.int)
+    reporting_loss = torch.cat([loss.clone().detach().view(1), num_tokens.view(1)])
+
+    return (loss, num_tokens, {'lm loss': reporting_loss})
+
+
+def forward_step(data_iterator, model: LLaVAModel):
+    """Forward training step.
+
+    Args:
+        data_iterator (torch.utils.data.dataloader): Input data iterator
+        model: Multimodal model
+
+    Returns:
+        output_tensor (torch.Tensor): Loss of shape [b, s] if labels are provided, otherwise logits of shape [b, s, vocab_size].
+        loss_func (callable): Loss function with a loss mask specified.
+    """
+    timers = get_timers()
+
+    # Get the batch.
+    timers('batch-generator', log_level=2).start()
+    (
+        tokens,
+        labels,
+        loss_mask,
+        attention_mask,
+        position_ids,
+        images,
+        num_image_tiles,
+        packed_seq_params,
+    ) = get_batch(data_iterator, model.module.module.image_token_index, model.module.module.img_seq_len)
+    timers('batch-generator').stop()
+
+    output_tensor, loss_mask = model(
+        images,
+        tokens,
+        position_ids,
+        attention_mask,
+        labels,
+        loss_mask,
+        num_image_tiles=num_image_tiles,
+        packed_seq_params=packed_seq_params,
+    )
+    args = get_args()
+    if args.use_loss_scaling:
+        loss_function = partial(scaled_loss_func, loss_mask)
+    else:
+        loss_function = partial(loss_func, loss_mask)
+
+    return output_tensor, loss_function
+
+
+def llava_embedding_ranks(pp_ranks):
+    """LLava's embedding ranks consist of the decoder's first and last ranks (ie, the ViT has no embeddings).
+    Args:
+        pp_ranks: A list of global ranks that constitute a pipeline group.
+    """
+    # With no separate encoder pipeline stages (epp=0), the decoder starts at rank 0
+    last_rank = pp_ranks[-1]
+    if len(pp_ranks) == 1:
+        return [last_rank]
+    else:
+        return [pp_ranks[0], last_rank]
+
+
+def llava_position_embedding_ranks(pp_ranks):
+    """LLava's embedding ranks consist of the singular rank of the model or the decoder's first rank.
+    Args:
+        pp_ranks: A list of global ranks that constitute a pipeline group.
+    """
+    # With no separate encoder pipeline stages (epp=0), the decoder starts at rank 0
+    last_rank = pp_ranks[-1]
+    if len(pp_ranks) == 1:
+        return [last_rank]
+    else:
+        return [pp_ranks[0]]
+
+
+def run_online_eval(model):
+    """Run an evaluation benchmark during training."""
+    args = get_args()
+
+    # Online evaluation config is not defined. Do nothing.
+    if not args.online_evaluation_config:
+        return []
+
+    from config import EvaluationConfig
+    # Import the common evaluation functions
+    from run_text_generation import get_evaluation_configs, run_evaluation_loop
+
+    # Use the common config loading function
+    configs = get_evaluation_configs(config_path=args.online_evaluation_config)
+
+    # The inference code assumes the first rank is the leader.
+    # Tensorboard writer is on the last rank.
+    # We must write to a storage space that all ranks see.
+    output_dir = os.path.join(args.save, "online_eval")
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Use the common evaluation loop
+    scores = run_evaluation_loop(model[0].module, configs, output_dir_override=output_dir, print_output=False)
+
+    return [scores]
+
+
+def write_eval_to_tensorboard(data, iteration, writer, walltime=None):
+    """Write evaluation data to Tensorboard."""
+    if not writer:
+        return
+
+    for item in data:
+        for k, v in item.items():
+            writer.add_scalar(k, v, iteration, walltime=walltime)
+
+
+def write_online_eval_to_tensorboard(data, iteration, writer, walltime=None):
+    """Write online evaluation data to Tensorboard."""
+    import shutil
+    args = get_args()
+
+    # Define source and destination directories
+    source_dir = os.path.join(args.save, "online_eval")
+    destination_dir = os.path.join(args.save, f"online_eval_{iteration}")
+    if os.path.exists(source_dir):
+        print("Moving online eval data from", source_dir, "to", destination_dir)
+
+        # Move the directory (back up the generation)
+        shutil.move(source_dir, destination_dir)
+
+    write_eval_to_tensorboard(data, iteration, writer, walltime)
+
+
+if __name__ == "__main__":
+
+    train_valid_test_dataloaders_provider.is_distributed = True
+
+    pretrain(
+        train_valid_test_dataloaders_provider,
+        model_provider,
+        ModelType.encoder_or_decoder,
+        forward_step,
+        args_defaults={'tokenizer_type': 'GPT2BPETokenizer'},
+        extra_args_provider=add_multimodal_extra_args,
+        process_non_loss_data_func=write_online_eval_to_tensorboard,
+        get_embedding_ranks=llava_embedding_ranks,
+        get_position_embedding_ranks=llava_position_embedding_ranks,
+        non_loss_data_func=run_online_eval,
+    )
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/Qwen/Qwen2.5-0.5B-Instruct.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/Qwen/Qwen2.5-0.5B-Instruct.sh
new file mode 100644
index 0000000000000000000000000000000000000000..2e6d8e3d7fcad75e64757df4ea6967b66ecd0823
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/Qwen/Qwen2.5-0.5B-Instruct.sh
@@ -0,0 +1,37 @@
+#!/bin/bash
+
+if [ -z ${HF_MODEL_CKPT} ]; then
+    HF_MODEL_CKPT=Qwen/Qwen2.5-0.5B
+    TOKENIZER_MODEL=Qwen/Qwen2.5-0.5B
+else
+    TOKENIZER_MODEL=${HF_MODEL_CKPT}
+fi
+
+MODEL_ARGS=" \
+    --save-interval 100000 \
+    --micro-batch-size 1 \
+    --bf16 \
+    --no-masked-softmax-fusion \
+    --disable-bias-linear \
+    --add-qkv-bias \
+    --position-embedding-type rope \
+    --no-rope-fusion \
+    --normalization RMSNorm \
+    --swiglu \
+    --num-layers 24 \
+    --hidden-size 896 \
+    --ffn-hidden-size 4864 \
+    --num-attention-heads 14 \
+    --group-query-attention \
+    --num-query-groups 2 \
+    --kv-channels 64 \
+    --seq-length 4096 \
+    --max-position-embeddings 32768 \
+    --tokenizer-type HuggingFaceTokenizer \
+    --padded-vocab-size 151936 \
+    --make-vocab-size-divisible-by 1 \
+    --use-mcore-models \
+    --rotary-percent 1.0 \
+    --rotary-base 1000000 \
+    --no-bias-swiglu-fusion \
+"
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/Qwen/Qwen2.5-7B-Instruct.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/Qwen/Qwen2.5-7B-Instruct.sh
new file mode 100644
index 0000000000000000000000000000000000000000..2388309fbeac6cacc2e945d876781655ebf8dbde
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/Qwen/Qwen2.5-7B-Instruct.sh
@@ -0,0 +1,38 @@
+#!/bin/bash
+
+if [ -z ${HF_MODEL_CKPT} ]; then
+    HF_MODEL_CKPT=Qwen/Qwen2.5-7B-Instruct
+    TOKENIZER_MODEL=Qwen/Qwen2.5-7B-Instruct
+else
+    TOKENIZER_MODEL=${HF_MODEL_CKPT}
+fi
+
+MODEL_ARGS=" \
+    --save-interval 100000 \
+    --micro-batch-size 1 \
+    --bf16 \
+    --no-masked-softmax-fusion \
+    --disable-bias-linear \
+    --add-qkv-bias \
+    --position-embedding-type rope \
+    --no-rope-fusion \
+    --normalization RMSNorm \
+    --swiglu \
+    --num-layers 28 \
+    --hidden-size 3584 \
+    --ffn-hidden-size 18944 \
+    --num-attention-heads 28 \
+    --group-query-attention \
+    --num-query-groups 4 \
+    --kv-channels 128 \
+    --seq-length 4096 \
+    --max-position-embeddings 32768 \
+    --tokenizer-type HuggingFaceTokenizer \
+    --padded-vocab-size 152064 \
+    --make-vocab-size-divisible-by 1 \
+    --use-mcore-models \
+    --rotary-percent 1.0 \
+    --rotary-base 1000000 \
+    --no-bias-swiglu-fusion \
+    --untie-embeddings-and-output-weights \
+"
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/Qwen/Qwen3-0.6B.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/Qwen/Qwen3-0.6B.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8eafc2a7b1a57e989fb2948bd6892eb79c4f0494
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/Qwen/Qwen3-0.6B.sh
@@ -0,0 +1,36 @@
+#!/bin/bash
+
+if [ -z ${HF_MODEL_CKPT} ]; then
+    HF_MODEL_CKPT=Qwen/Qwen3-0.6B
+    TOKENIZER_MODEL=Qwen/Qwen3-0.6B
+else
+    TOKENIZER_MODEL=${HF_MODEL_CKPT}
+fi
+
+MODEL_ARGS=" \
+    --save-interval 100000 \
+    --micro-batch-size 1 \
+    --bf16 \
+    --no-masked-softmax-fusion \
+    --disable-bias-linear \
+    --position-embedding-type rope \
+    --no-rope-fusion \
+    --normalization RMSNorm \
+    --swiglu \
+    --num-layers 28 \
+    --hidden-size 1024 \
+    --ffn-hidden-size 3072 \
+    --num-attention-heads 16 \
+    --group-query-attention \
+    --num-query-groups 8 \
+    --kv-channels 128 \
+    --qk-layernorm \
+    --seq-length 4096 \
+    --max-position-embeddings 40960 \
+    --tokenizer-type HuggingFaceTokenizer \
+    --make-vocab-size-divisible-by 1187 \
+    --use-mcore-models \
+    --rotary-percent 1.0 \
+    --rotary-base 1000000 \
+    --no-bias-swiglu-fusion \
+"
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/Qwen/Qwen3-235B-A22B.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/Qwen/Qwen3-235B-A22B.sh
new file mode 100644
index 0000000000000000000000000000000000000000..0241cac97b3d9e43dabab88f7a505c06ec233a21
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/Qwen/Qwen3-235B-A22B.sh
@@ -0,0 +1,49 @@
+#!/bin/bash
+
+if [ -z ${HF_MODEL_CKPT} ]; then
+    HF_MODEL_CKPT=Qwen/Qwen3-235B-A22B
+    TOKENIZER_MODEL=Qwen/Qwen3-235B-A22B
+else
+    TOKENIZER_MODEL=${HF_MODEL_CKPT}
+fi
+
+MODEL_ARGS=" \
+    --save-interval 100000 \
+    --micro-batch-size 1 \
+    --bf16 \
+    --no-masked-softmax-fusion \
+    --disable-bias-linear \
+    --untie-embeddings-and-output-weights \
+    --position-embedding-type rope \
+    --no-rope-fusion \
+    --normalization RMSNorm \
+    --swiglu \
+    --num-layers 94 \
+    --hidden-size 4096 \
+    --ffn-hidden-size 12288 \
+    --num-attention-heads 64 \
+    --group-query-attention \
+    --num-query-groups 4 \
+    --kv-channels 128 \
+    --qk-layernorm \
+    --num-experts 128 \
+    --moe-ffn-hidden-size 1536 \
+    --moe-router-topk 8 \
+    --moe-router-dtype fp32 \
+    --moe-aux-loss-coeff 1e-3 \
+    --moe-token-dispatcher-type alltoall \
+    --moe-router-load-balancing-type aux_loss \
+    --moe-layer-recompute \
+    --seq-length 4096 \
+    --max-position-embeddings 40960 \
+    --tokenizer-type HuggingFaceTokenizer \
+    --make-vocab-size-divisible-by 1187 \
+    --use-mcore-models \
+    --rotary-percent 1.0 \
+    --rotary-base 1000000 \
+    --rotary-seq-len-interpolation-factor 1 \
+    --no-bias-swiglu-fusion \
+    --attention-dropout 0.0 \
+    --hidden-dropout 0.0 \
+    --sequence-parallel \
+"
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/Qwen/Qwen3-30B-A3B.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/Qwen/Qwen3-30B-A3B.sh
new file mode 100644
index 0000000000000000000000000000000000000000..425cf0c2490d5b1ee2d69ade71b4b22723087d9a
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/Qwen/Qwen3-30B-A3B.sh
@@ -0,0 +1,45 @@
+#!/bin/bash
+
+if [ -z ${HF_MODEL_CKPT} ]; then
+    HF_MODEL_CKPT=Qwen/Qwen3-30B-A3B
+    TOKENIZER_MODEL=Qwen/Qwen3-30B-A3B
+else
+    TOKENIZER_MODEL=${HF_MODEL_CKPT}
+fi
+
+MODEL_ARGS=" \
+    --save-interval 100000 \
+    --micro-batch-size 1 \
+    --bf16 \
+    --no-masked-softmax-fusion \
+    --disable-bias-linear \
+    --untie-embeddings-and-output-weights \
+    --position-embedding-type rope \
+    --no-rope-fusion \
+    --normalization RMSNorm \
+    --swiglu \
+    --num-layers 48 \
+    --hidden-size 2048 \
+    --ffn-hidden-size 6144 \
+    --num-attention-heads 32 \
+    --group-query-attention \
+    --num-query-groups 4 \
+    --kv-channels 128 \
+    --qk-layernorm \
+    --num-experts 128 \
+    --moe-ffn-hidden-size 768 \
+    --moe-router-topk 8 \
+    --moe-router-dtype fp32 \
+    --moe-aux-loss-coeff 1e-3 \
+    --moe-token-dispatcher-type alltoall \
+    --moe-router-load-balancing-type aux_loss \
+    --seq-length 4096 \
+    --max-position-embeddings 40960 \
+    --tokenizer-type HuggingFaceTokenizer \
+    --make-vocab-size-divisible-by 1187 \
+    --use-mcore-models \
+    --rotary-percent 1.0 \
+    --rotary-base 1000000 \
+    --no-bias-swiglu-fusion \
+    --sequence-parallel \
+"
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/Qwen/Qwen3-8B.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/Qwen/Qwen3-8B.sh
new file mode 100644
index 0000000000000000000000000000000000000000..2de97212aeff115c7482f3d9afda1122ac3defd9
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/Qwen/Qwen3-8B.sh
@@ -0,0 +1,37 @@
+#!/bin/bash
+
+if [ -z ${HF_MODEL_CKPT} ]; then
+    HF_MODEL_CKPT=Qwen/Qwen3-8B
+    TOKENIZER_MODEL=Qwen/Qwen3-8B
+else
+    TOKENIZER_MODEL=${HF_MODEL_CKPT}
+fi
+
+MODEL_ARGS=" \
+    --save-interval 100000 \
+    --micro-batch-size 1 \
+    --bf16 \
+    --no-masked-softmax-fusion \
+    --disable-bias-linear \
+    --untie-embeddings-and-output-weights \
+    --position-embedding-type rope \
+    --no-rope-fusion \
+    --normalization RMSNorm \
+    --swiglu \
+    --num-layers 36 \
+    --hidden-size 4096 \
+    --ffn-hidden-size 12288 \
+    --num-attention-heads 32 \
+    --group-query-attention \
+    --num-query-groups 8 \
+    --kv-channels 128 \
+    --qk-layernorm \
+    --seq-length 4096 \
+    --max-position-embeddings 40960 \
+    --tokenizer-type HuggingFaceTokenizer \
+    --make-vocab-size-divisible-by 1187 \
+    --use-mcore-models \
+    --rotary-percent 1.0 \
+    --rotary-base 1000000 \
+    --no-bias-swiglu-fusion \
+"
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/deepseek-ai/DeepSeek-R1.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/deepseek-ai/DeepSeek-R1.sh
new file mode 100644
index 0000000000000000000000000000000000000000..bf9b7b73d3b925fafec563dc3f1c735f0dc33362
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/deepseek-ai/DeepSeek-R1.sh
@@ -0,0 +1,61 @@
+#!/bin/bash
+
+TOKENIZER_MODEL="deepseek-ai/DeepSeek-R1"
+
+MODEL_ARGS=" \
+    --save-interval 100000 \
+    --micro-batch-size 1 \
+    --bf16 \
+    --no-masked-softmax-fusion \
+    --disable-bias-linear \
+    --untie-embeddings-and-output-weights \
+    --position-embedding-type rope \
+    --no-rope-fusion \
+    --normalization RMSNorm \
+    --swiglu \
+    --num-layers 61 \
+    --hidden-size 7168 \
+    --ffn-hidden-size 18432 \
+    --num-attention-heads 128 \
+    --kv-channels 128 \
+    --multi-latent-attention \
+    --kv-lora-rank 512 \
+    --v-head-dim 128 \
+    --q-lora-rank 1536 \
+    --qk-head-dim 128 \
+    --qk-layernorm \
+    --qk-pos-emb-head-dim 64 \
+    --num-experts 256 \
+    --moe-layer-freq [0]*3+[1]*58 \
+    --moe-ffn-hidden-size 2048 \
+    --moe-router-dtype fp32 \
+    --moe-router-score-function sigmoid \
+    --moe-router-bias-update-rate 1e-3 \
+    --moe-router-enable-expert-bias \
+    --moe-router-topk 8 \
+    --moe-router-num-groups 8 \
+    --moe-router-group-topk 4 \
+    --moe-router-pre-softmax \
+    --moe-router-topk-scaling-factor 2.5 \
+    --moe-shared-expert-overlap \
+    --moe-shared-expert-intermediate-size 2048 \
+    --moe-aux-loss-coeff 1e-4 \
+    --moe-router-load-balancing-type seq_aux_loss \
+    --moe-token-dispatcher-type alltoall \
+    --moe-token-drop-policy probs \
+    --seq-length 4096 \
+    --max-position-embeddings 163840 \
+    --tokenizer-type HuggingFaceTokenizer \
+    --make-vocab-size-divisible-by 1280 \
+    --use-mcore-models \
+    --rotary-base 10000 \
+    --rotary-percent 1.0 \
+    --rotary-scaling-factor 40 \
+    --mscale 1.0 \
+    --mscale-all-dim 1.0 \
+    --recompute-activations \
+    --moe-layer-recompute \
+    --sequence-parallel \
+"
+#    --decoder-first-pipeline-num-layers 6 \
+#    --decoder-last-pipeline-num-layers 7 \
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/deepseek-ai/DeepSeek-V2-Lite.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/deepseek-ai/DeepSeek-V2-Lite.sh
new file mode 100644
index 0000000000000000000000000000000000000000..fdaccbd9651c107c1e913096a18758f1d23bebb9
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/deepseek-ai/DeepSeek-V2-Lite.sh
@@ -0,0 +1,55 @@
+#!/bin/bash
+
+TOKENIZER_MODEL="deepseek-ai/DeepSeek-V2-Lite"
+
+MODEL_ARGS=" \
+    --save-interval 100000 \
+    --attention-dropout 0.0 \
+    --hidden-dropout 0.0 \
+    --micro-batch-size 1 \
+    --bf16 \
+    --no-masked-softmax-fusion \
+    --disable-bias-linear \
+    --untie-embeddings-and-output-weights \
+    --position-embedding-type rope \
+    --no-rope-fusion \
+    --normalization RMSNorm \
+    --norm-epsilon 1e-6 \
+    --swiglu \
+    --num-layers 27 \
+    --hidden-size 2048 \
+    --ffn-hidden-size 10944 \
+    --num-attention-heads 16 \
+    --kv-channels 16 \
+    --multi-latent-attention \
+    --kv-lora-rank 512 \
+    --v-head-dim 128 \
+    --qk-head-dim 128 \
+    --qk-layernorm \
+    --qk-pos-emb-head-dim 64 \
+    --num-experts 64 \
+    --moe-layer-freq ([0]+[1]*26) \
+    --moe-ffn-hidden-size 1408 \
+    --moe-grouped-gemm \
+    --moe-router-score-function softmax \
+    --moe-router-topk 6 \
+    --moe-router-topk-scaling-factor 1.0 \
+    --moe-router-pre-softmax \
+    --moe-shared-expert-intermediate-size 2816 \
+    --moe-aux-loss-coeff 1e-3 \
+    --moe-token-dispatcher-type alltoall \
+    --moe-token-drop-policy probs \
+    --moe-router-load-balancing-type seq_aux_loss \
+    --seq-length 1024 \
+    --max-position-embeddings 1024 \
+    --tokenizer-type HuggingFaceTokenizer \
+    --make-vocab-size-divisible-by 3200 \
+    --attention-softmax-in-fp32 \
+    --use-mcore-models \
+    --rotary-percent 1.0 \
+    --rotary-base 10000 \
+    --rotary-scaling-factor 40 \
+    --mscale 0.707 \
+    --mscale-all-dim 0.707 \
+    --sequence-parallel \
+"
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/meta-llama/Llama-3.1-8B-Instruct.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/meta-llama/Llama-3.1-8B-Instruct.sh
new file mode 100644
index 0000000000000000000000000000000000000000..5d8c6d1c55aa424c65914020c0af90710d8a9a35
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/meta-llama/Llama-3.1-8B-Instruct.sh
@@ -0,0 +1,36 @@
+#!/bin/bash
+
+if [ -z ${HF_MODEL_CKPT} ]; then
+    HF_MODEL_CKPT=meta-llama/Llama-3.1-8B-Instruct
+    TOKENIZER_MODEL=nvidia/Llama-3.1-70B-Instruct-FP8
+else
+    TOKENIZER_MODEL=${HF_MODEL_CKPT}
+fi
+
+MODEL_ARGS=" \
+    --save-interval 100000 \
+    --micro-batch-size 1 \
+    --bf16 \
+    --no-masked-softmax-fusion \
+    --disable-bias-linear \
+    --untie-embeddings-and-output-weights \
+    --use-rotary-position-embeddings \
+    --rotary-percent 1.0 \
+    --no-rope-fusion \
+    --no-position-embedding \
+    --normalization RMSNorm \
+    --swiglu \
+    --num-layers 32 \
+    --hidden-size 4096 \
+    --ffn-hidden-size 14336 \
+    --num-attention-heads 32 \
+    --group-query-attention \
+    --num-query-groups 8 \
+    --seq-length 4096 \
+    --max-position-embeddings 8192 \
+    --tokenizer-type HuggingFaceTokenizer \
+    --make-vocab-size-divisible-by 1 \
+    --use-mcore-models \
+    --rotary-base 500000 \
+    --use-rope-scaling \
+"
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/meta-llama/Llama-3.2-1B-Instruct.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/meta-llama/Llama-3.2-1B-Instruct.sh
new file mode 100644
index 0000000000000000000000000000000000000000..c64cd06ccfe7e2f876897ed8c545ca694c17aece
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/meta-llama/Llama-3.2-1B-Instruct.sh
@@ -0,0 +1,36 @@
+#!/bin/bash
+
+if [ -z ${HF_MODEL_CKPT} ]; then
+    HF_MODEL_CKPT=meta-llama/Llama-3.2-1B-Instruct
+    TOKENIZER_MODEL=nvidia/Llama-3.1-70B-Instruct-FP8
+else
+    TOKENIZER_MODEL=${HF_MODEL_CKPT}
+fi
+
+MODEL_ARGS=" \
+    --save-interval 100000 \
+    --micro-batch-size 1 \
+    --bf16 \
+    --no-masked-softmax-fusion \
+    --disable-bias-linear \
+    --use-rotary-position-embeddings \
+    --no-rope-fusion \
+    --no-position-embedding \
+    --normalization RMSNorm \
+    --swiglu \
+    --num-layers 16 \
+    --hidden-size 2048 \
+    --ffn-hidden-size 8192 \
+    --num-attention-heads 32 \
+    --group-query-attention \
+    --num-query-groups 8 \
+    --seq-length 4096 \
+    --max-position-embeddings 8192 \
+    --tokenizer-type HuggingFaceTokenizer \
+    --make-vocab-size-divisible-by 1 \
+    --use-mcore-models \
+    --rotary-percent 1.0 \
+    --rotary-base 500000 \
+    --use-rope-scaling \
+"
+#    --export-force-local-attention \
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/meta-llama/Llama-4-Maverick-17B-128E-Instruct.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/meta-llama/Llama-4-Maverick-17B-128E-Instruct.sh
new file mode 100644
index 0000000000000000000000000000000000000000..f5669a3e796032b842515678c0d376f5e02dd0ae
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/meta-llama/Llama-4-Maverick-17B-128E-Instruct.sh
@@ -0,0 +1,53 @@
+#!/bin/bash
+
+if [ -z ${HF_MODEL_CKPT} ]; then
+    HF_MODEL_CKPT=meta-llama/Llama-4-Maverick-17B-128E-Instruct
+    TOKENIZER_MODEL=meta-llama/Llama-4-Maverick-17B-128E-Instruct
+else
+    TOKENIZER_MODEL=${HF_MODEL_CKPT}
+fi
+
+MODEL_ARGS=" \
+    --recompute-activations \
+    --save-interval 100000 \
+    --micro-batch-size 1 \
+    --bf16 \
+    --no-masked-softmax-fusion \
+    --disable-bias-linear \
+    --untie-embeddings-and-output-weights \
+    --position-embedding-type rope \
+    --no-rope-fusion \
+    --normalization RMSNorm \
+    --swiglu \
+    --num-layers 48 \
+    --hidden-size 5120 \
+    --ffn-hidden-size 16384 \
+    --num-attention-heads 40 \
+    --group-query-attention \
+    --num-query-groups 8 \
+    --num-experts 128 \
+    --moe-layer-freq ([0,1]*24) \
+    --moe-layer-recompute \
+    --moe-ffn-hidden-size 8192 \
+    --moe-router-score-function sigmoid \
+    --moe-router-topk 1 \
+    --moe-router-topk-scaling-factor 1.0 \
+    --moe-router-dtype fp32 \
+    --moe-shared-expert-intermediate-size 8192 \
+    --moe-aux-loss-coeff 1e-3 \
+    --moe-token-dispatcher-type alltoall \
+    --moe-token-drop-policy probs \
+    --moe-router-load-balancing-type seq_aux_loss \
+    --seq-length 2048 \
+    --max-position-embeddings 2048 \
+    --tokenizer-type HuggingFaceTokenizer \
+    --make-vocab-size-divisible-by 1 \
+    --use-mcore-models \
+    --rotary-percent 1.0 \
+    --rope-scaling-factor 8.0 \
+    --rotary-base 500000 \
+    --rotary-interleaved \
+    --no-rope-freq 4 \
+    --export-moe-apply-probs-on-input \
+    --padded-vocab-size 202048 \
+"
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/meta-llama/Llama-4-Scout-17B-16E-Instruct.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/meta-llama/Llama-4-Scout-17B-16E-Instruct.sh
new file mode 100644
index 0000000000000000000000000000000000000000..3456a1e32d065412d6bca578b4bcc85a1dd042ed
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/meta-llama/Llama-4-Scout-17B-16E-Instruct.sh
@@ -0,0 +1,54 @@
+#!/bin/bash
+
+if [ -z ${HF_MODEL_CKPT} ]; then
+    HF_MODEL_CKPT=meta-llama/Llama-4-Scout-17B-16E-Instruct
+    TOKENIZER_MODEL=meta-llama/Llama-4-Scout-17B-16E-Instruct
+else
+    TOKENIZER_MODEL=${HF_MODEL_CKPT}
+fi
+
+MODEL_ARGS=" \
+    --save-interval 100000 \
+    --micro-batch-size 1 \
+    --bf16 \
+    --no-masked-softmax-fusion \
+    --disable-bias-linear \
+    --untie-embeddings-and-output-weights \
+    --position-embedding-type rope \
+    --no-rope-fusion \
+    --normalization RMSNorm \
+    --swiglu \
+    --num-layers 48 \
+    --hidden-size 5120 \
+    --ffn-hidden-size 16384 \
+    --num-attention-heads 40 \
+    --group-query-attention \
+    --num-query-groups 8 \
+    --qk-layernorm \
+    --num-experts 16 \
+    --moe-ffn-hidden-size 8192 \
+    --moe-router-score-function sigmoid \
+    --moe-router-topk 1 \
+    --moe-router-topk-scaling-factor 1.0 \
+    --moe-router-dtype fp32 \
+    --moe-shared-expert-intermediate-size 8192 \
+    --moe-aux-loss-coeff 1e-3 \
+    --moe-token-dispatcher-type alltoall \
+    --moe-token-drop-policy probs \
+    --moe-router-load-balancing-type seq_aux_loss \
+    --seq-length 4096 \
+    --max-position-embeddings 4096 \
+    --tokenizer-type HuggingFaceTokenizer \
+    --make-vocab-size-divisible-by 128 \
+    --use-mcore-models \
+    --rotary-interleaved \
+    --rotary-percent 1.0 \
+    --rotary-base 500000 \
+    --rope-scaling-factor 8.0 \
+    --use-rope-scaling \
+    --sequence-parallel \
+    --no-bias-swiglu-fusion \
+    --export-qk-l2-norm \
+    --export-moe-apply-probs-on-input \
+    --padded-vocab-size 202048 \
+"
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16.sh
new file mode 100644
index 0000000000000000000000000000000000000000..1fa00889e991404eecdec2976b7638050b3f2a81
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16.sh
@@ -0,0 +1,55 @@
+#!/bin/bash
+
+if [ -z ${HF_MODEL_CKPT} ]; then
+    HF_MODEL_CKPT=nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16
+    TOKENIZER_MODEL=nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16
+else
+    TOKENIZER_MODEL=${HF_MODEL_CKPT}
+fi
+
+MODEL_ARGS=" \
+    --trust-remote-code \
+    --save-interval 100000 \
+    --micro-batch-size 1 \
+    --moe-token-dispatcher-type allgather \
+    --enable-experimental \
+    --moe-permute-fusion \
+    --use-fused-weighted-squared-relu \
+    --cross-entropy-loss-fusion \
+    --cross-entropy-fusion-impl native \
+    --moe-router-score-function sigmoid \
+    --moe-grouped-gemm \
+    --num-experts 128 \
+    --moe-router-topk 6 \
+    --moe-aux-loss-coeff 1e-4 \
+    --moe-router-topk-scaling-factor 2.5 \
+    --moe-router-enable-expert-bias \
+    --moe-router-dtype fp32 \
+    --moe-router-load-balancing-type seq_aux_loss \
+    --moe-shared-expert-intermediate-size 3712 \
+    \
+    --attention-backend flash \
+    --disable-gloo-process-groups \
+    --mamba-num-heads 64 \
+    --mamba-head-dim 64 \
+    --hybrid-layer-pattern MEMEM*EMEMEM*EMEMEM*EMEMEM*EMEMEM*EMEMEMEM*EMEMEMEME \
+    --use-mcore-models \
+    --untie-embeddings-and-output-weights \
+    --disable-bias-linear \
+    --init-method-std 0.0173 \
+    --position-embedding-type none \
+    --squared-relu \
+    --hidden-size 2688 \
+    --num-attention-heads 32 \
+    --group-query-attention \
+    --num-query-groups 2 \
+    --ffn-hidden-size 1856 \
+    --kv-channels 128 \
+    --normalization RMSNorm \
+    \
+    --tokenizer-type HuggingFaceTokenizer \
+    --bf16 \
+    --seq-length 8192 \
+    --max-position-embeddings 8192 \
+    --export-model-type MambaModel \
+    "
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16.sh
new file mode 100644
index 0000000000000000000000000000000000000000..977be033df00c341f21315413e3d4b0b764d7209
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16.sh
@@ -0,0 +1,62 @@
+#!/bin/bash
+
+if [ -z ${HF_MODEL_CKPT} ]; then
+    HF_MODEL_CKPT=nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16
+    TOKENIZER_MODEL=nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16
+else
+    TOKENIZER_MODEL=${HF_MODEL_CKPT}
+fi
+
+
+
+MODEL_ARGS=" \
+    --trust-remote-code \
+    --save-interval 100000 \
+    --micro-batch-size 1 \
+    --enable-experimental \
+    --use-fused-weighted-squared-relu \
+    --cross-entropy-loss-fusion \
+    --cross-entropy-fusion-impl native \
+    --num-experts 512 \
+    --moe-router-score-function sigmoid \
+    --moe-grouped-gemm \
+    --moe-aux-loss-coeff 1e-4 \
+    --moe-router-topk 22 \
+    --moe-permute-fusion \
+    --moe-router-topk-scaling-factor 5.0 \
+    --moe-router-enable-expert-bias \
+    --moe-router-dtype fp32 \
+    --moe-router-load-balancing-type seq_aux_loss \
+    --moe-shared-expert-intermediate-size 5376 \
+    --moe-token-dispatcher-type allgather \
+    --moe-latent-size 1024 \
+    \
+    --attention-backend flash \
+    --disable-gloo-process-groups \
+    --is-hybrid-model \
+    --mamba-num-heads 128 \
+    --mamba-head-dim 64 \
+    --hybrid-layer-pattern MEMEMEM*EMEMEMEM*EMEMEMEM*EMEMEMEMEM*EMEMEMEMEM*EMEMEMEMEM*EMEMEMEMEM*EMEMEMEM*EMEMEMEME \
+    \
+    --use-mcore-models \
+    --untie-embeddings-and-output-weights \
+    --disable-bias-linear \
+    --init-method-std 0.014 \
+    --position-embedding-type none \
+    --squared-relu \
+    --hidden-size 4096 \
+    --num-attention-heads 32 \
+    --group-query-attention \
+    --num-query-groups 2 \
+    --ffn-hidden-size 2688 \
+    --kv-channels 128 \
+    --normalization RMSNorm \
+    --attention-dropout 0.0 \
+    --hidden-dropout 0.0 \
+    \
+    --tokenizer-type HuggingFaceTokenizer \
+    --bf16 \
+    --seq-length 8192 \
+    --max-position-embeddings 8192 \
+    --export-model-type MambaModel \
+    "
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/NVIDIA-Nemotron-Nano-9B-v2-Base.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/NVIDIA-Nemotron-Nano-9B-v2-Base.sh
new file mode 100644
index 0000000000000000000000000000000000000000..83867430a97ee713f6069c0cd1a57ebfdb5bbdd7
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/NVIDIA-Nemotron-Nano-9B-v2-Base.sh
@@ -0,0 +1,40 @@
+#!/bin/bash
+
+if [ -z ${HF_MODEL_CKPT} ]; then
+    HF_MODEL_CKPT=nvidia/NVIDIA-Nemotron-Nano-9B-v2-Base
+    TOKENIZER_MODEL=nvidia/NVIDIA-Nemotron-Nano-9B-v2-Base
+else
+    TOKENIZER_MODEL=${HF_MODEL_CKPT}
+fi
+
+MODEL_ARGS=" \
+    --trust-remote-code \
+    --save-interval 100000 \
+    --micro-batch-size 1 \
+    --bf16 \
+    --no-masked-softmax-fusion \
+    --disable-bias-linear \
+    --untie-embeddings-and-output-weights \
+    --position-embedding-type none \
+    --no-rope-fusion \
+    --normalization RMSNorm \
+    --squared-relu \
+    --hidden-size 4480 \
+    --ffn-hidden-size 15680 \
+    --num-attention-heads 40 \
+    --kv-channels 128 \
+    --group-query-attention \
+    --num-query-groups 8 \
+    --hybrid-layer-pattern M-M-M-MM-M-M-M*-M-M-M*-M-M-M-M*-M-M-M-M*-M-MM-M-M-M-M-M- \
+    --mamba-head-dim 80 \
+    --mamba-num-heads 128 \
+    --mamba-num-groups 8 \
+    --mamba-state-dim 128 \
+    --seq-length 4096 \
+    --max-position-embeddings 131072 \
+    --tokenizer-type HuggingFaceTokenizer \
+    --make-vocab-size-divisible-by 1 \
+    --use-mcore-models \
+    --export-model-type MambaModel \
+    --padded-vocab-size 131072 \
+"
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/NVIDIA-Nemotron-Nano-9B-v2.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/NVIDIA-Nemotron-Nano-9B-v2.sh
new file mode 100644
index 0000000000000000000000000000000000000000..83867430a97ee713f6069c0cd1a57ebfdb5bbdd7
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/NVIDIA-Nemotron-Nano-9B-v2.sh
@@ -0,0 +1,40 @@
+#!/bin/bash
+
+if [ -z ${HF_MODEL_CKPT} ]; then
+    HF_MODEL_CKPT=nvidia/NVIDIA-Nemotron-Nano-9B-v2-Base
+    TOKENIZER_MODEL=nvidia/NVIDIA-Nemotron-Nano-9B-v2-Base
+else
+    TOKENIZER_MODEL=${HF_MODEL_CKPT}
+fi
+
+MODEL_ARGS=" \
+    --trust-remote-code \
+    --save-interval 100000 \
+    --micro-batch-size 1 \
+    --bf16 \
+    --no-masked-softmax-fusion \
+    --disable-bias-linear \
+    --untie-embeddings-and-output-weights \
+    --position-embedding-type none \
+    --no-rope-fusion \
+    --normalization RMSNorm \
+    --squared-relu \
+    --hidden-size 4480 \
+    --ffn-hidden-size 15680 \
+    --num-attention-heads 40 \
+    --kv-channels 128 \
+    --group-query-attention \
+    --num-query-groups 8 \
+    --hybrid-layer-pattern M-M-M-MM-M-M-M*-M-M-M*-M-M-M-M*-M-M-M-M*-M-MM-M-M-M-M-M- \
+    --mamba-head-dim 80 \
+    --mamba-num-heads 128 \
+    --mamba-num-groups 8 \
+    --mamba-state-dim 128 \
+    --seq-length 4096 \
+    --max-position-embeddings 131072 \
+    --tokenizer-type HuggingFaceTokenizer \
+    --make-vocab-size-divisible-by 1 \
+    --use-mcore-models \
+    --export-model-type MambaModel \
+    --padded-vocab-size 131072 \
+"
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/Nemotron-H-47B-Reasoning-128K.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/Nemotron-H-47B-Reasoning-128K.sh
new file mode 100644
index 0000000000000000000000000000000000000000..901e607f2987c105bdaa192a1d33ac029118af72
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/Nemotron-H-47B-Reasoning-128K.sh
@@ -0,0 +1,37 @@
+#!/bin/bash
+
+if [ -z ${HF_MODEL_CKPT} ]; then
+    HF_MODEL_CKPT=nvidia/Nemotron-H-47B-Reasoning-128K
+    TOKENIZER_MODEL=nvidia/Nemotron-H-47B-Reasoning-128K
+else
+    TOKENIZER_MODEL=${HF_MODEL_CKPT}
+fi
+
+MODEL_ARGS=" \
+    --trust-remote-code \
+    --save-interval 100000 \
+    --micro-batch-size 1 \
+    --bf16 \
+    --attention-backend flash \
+    --disable-bias-linear \
+    --untie-embeddings-and-output-weights \
+    --position-embedding-type none \
+    --normalization RMSNorm \
+    --squared-relu \
+    --hidden-size 8192 \
+    --ffn-hidden-size 30720 \
+    --num-attention-heads 64 \
+    --kv-channels 128 \
+    --group-query-attention \
+    --num-query-groups 8 \
+    --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*-M-M-M-M-M*-M-M-M-M-M-M-M---MM---M-M*-M-M-M-M-M- \
+    --mamba-head-dim 64 \
+    --mamba-num-heads 256 \
+    --mamba-num-groups 8 \
+    --mamba-state-dim 256 \
+    --seq-length 8192 \
+    --max-position-embeddings 8192 \
+    --tokenizer-type HuggingFaceTokenizer \
+    --use-mcore-models \
+    --export-model-type MambaModel \
+"
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/Nemotron-H-4B-Instruct.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/Nemotron-H-4B-Instruct.sh
new file mode 100644
index 0000000000000000000000000000000000000000..084db49e0eb9e19b8ab636f4d02e06ff194fd1c6
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/Nemotron-H-4B-Instruct.sh
@@ -0,0 +1,42 @@
+#!/bin/bash
+
+if [ -z ${HF_MODEL_CKPT} ]; then
+    HF_MODEL_CKPT=nvidia/Nemotron-H-4B-Instruct
+    TOKENIZER_MODEL=nvidia/Nemotron-H-4B-Instruct
+else
+    TOKENIZER_MODEL=${HF_MODEL_CKPT}
+fi
+
+MODEL_ARGS=" \
+    --trust-remote-code \
+    --save-interval 100000 \
+    --micro-batch-size 1 \
+    --bf16 \
+    --no-masked-softmax-fusion \
+    --disable-bias-linear \
+    --untie-embeddings-and-output-weights \
+    --use-rotary-position-embeddings \
+    --rotary-percent 0.5 \
+    --no-rope-fusion \
+    --no-position-embedding \
+    --normalization RMSNorm \
+    --squared-relu \
+    --hidden-size 3072 \
+    --ffn-hidden-size 12288 \
+    --kv-channels 128 \
+    --num-attention-heads 32 \
+    --group-query-attention \
+    --num-query-groups 8 \
+    --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- \
+    --mamba-head-dim 64 \
+    --mamba-num-heads 112 \
+    --mamba-num-groups 8 \
+    --mamba-state-dim 128 \
+    --seq-length 4096 \
+    --max-position-embeddings 8192 \
+    --tokenizer-type HuggingFaceTokenizer \
+    --make-vocab-size-divisible-by 1 \
+    --use-mcore-models \
+    --rotary-base 10000 \
+    --export-model-type MambaModel \
+"
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/Nemotron-H-56B-Base-8K.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/Nemotron-H-56B-Base-8K.sh
new file mode 100644
index 0000000000000000000000000000000000000000..645a159d0758934a23c04910a4a547a987f7e837
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/Nemotron-H-56B-Base-8K.sh
@@ -0,0 +1,39 @@
+#!/bin/bash
+
+if [ -z ${HF_MODEL_CKPT} ]; then
+    HF_MODEL_CKPT=nvidia/Nemotron-H-56B-Base-8K
+    TOKENIZER_MODEL=nvidia/Nemotron-H-56B-Base-8K
+else
+    TOKENIZER_MODEL=${HF_MODEL_CKPT}
+fi
+
+MODEL_ARGS=" \
+    --trust-remote-code \
+    --save-interval 100000 \
+    --micro-batch-size 1 \
+    --attention-backend flash \
+    --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*-M-M-M-M-M*-M-M-M-M-M*-M-M-M-M-M*-M-M-M-M-M*-M-M-M-M-M*-M-M-M-M-M- \
+    --mamba-state-dim 256 \
+    --tiktoken-pattern v2 \
+    --use-mcore-models \
+    --untie-embeddings-and-output-weights \
+    --disable-bias-linear \
+    --init-method-std 0.0099 \
+    --position-embedding-type none \
+    --squared-relu \
+    --hidden-size 8192 \
+    --num-attention-heads 64 \
+    --group-query-attention \
+    --num-query-groups 8 \
+    --ffn-hidden-size 32768 \
+    --kv-channels 128 \
+    --normalization RMSNorm \
+    --exit-duration-in-mins 230 \
+    --tensor-model-parallel-size 8 \
+    --pipeline-model-parallel-size 1 \
+    --seq-length 8192 \
+    --max-position-embeddings 8192 \
+    --tokenizer-type HuggingFaceTokenizer \
+    --bf16 \
+    --export-model-type MambaModel \
+    "
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/Nemotron-H-8B-Base-8K.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/Nemotron-H-8B-Base-8K.sh
new file mode 100644
index 0000000000000000000000000000000000000000..66f3ad368b462662bc75970ac73027765a436526
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/Nemotron-H-8B-Base-8K.sh
@@ -0,0 +1,42 @@
+#!/bin/bash
+
+if [ -z ${HF_MODEL_CKPT} ]; then
+    HF_MODEL_CKPT=nvidia/Nemotron-H-8B-Base-8K
+    TOKENIZER_MODEL=nvidia/Nemotron-H-8B-Base-8K
+else
+    TOKENIZER_MODEL=${HF_MODEL_CKPT}
+fi
+
+MODEL_ARGS=" \
+    --trust-remote-code \
+    --save-interval 100000 \
+    --micro-batch-size 1 \
+    --bf16 \
+    --no-masked-softmax-fusion \
+    --disable-bias-linear \
+    --untie-embeddings-and-output-weights \
+    --use-rotary-position-embeddings \
+    --no-rope-fusion \
+    --no-position-embedding \
+    --normalization RMSNorm \
+    --squared-relu \
+    --hidden-size 4096 \
+    --ffn-hidden-size 21504 \
+    --num-attention-heads 32 \
+    --group-query-attention \
+    --num-query-groups 8 \
+    --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- \
+    --mamba-head-dim 64 \
+    --mamba-num-heads 128 \
+    --mamba-num-groups 8 \
+    --mamba-state-dim 128 \
+    --seq-length 4096 \
+    --max-position-embeddings 8192 \
+    --tokenizer-type HuggingFaceTokenizer \
+    --make-vocab-size-divisible-by 1 \
+    --use-mcore-models \
+    --rotary-percent 0.5 \
+    --rotary-base 500000 \
+    --export-model-type MambaModel \
+"
+#    --rotary-base 10000 \
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/Nemotron-Mini-4B-Instruct.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/Nemotron-Mini-4B-Instruct.sh
new file mode 100644
index 0000000000000000000000000000000000000000..d2c4cda36b25c70e42c2bd568fd7887b5697bed6
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/nvidia/Nemotron-Mini-4B-Instruct.sh
@@ -0,0 +1,37 @@
+#!/bin/bash
+
+if [ -z ${HF_MODEL_CKPT} ]; then
+    HF_MODEL_CKPT=nvidia/Nemotron-Mini-4B-Instruct
+    TOKENIZER_MODEL=nvidia/Nemotron-Mini-4B-Instruct
+else
+    TOKENIZER_MODEL=${HF_MODEL_CKPT}
+fi
+
+MODEL_ARGS=" \
+    --trust-remote-code \
+    --save-interval 100000 \
+    --micro-batch-size 1 \
+    --bf16 \
+    --no-masked-softmax-fusion \
+    --disable-bias-linear \
+    --untie-embeddings-and-output-weights \
+    --use-rotary-position-embeddings \
+    --rotary-percent 0.5 \
+    --no-rope-fusion \
+    --no-position-embedding \
+    --normalization LayerNorm \
+    --apply-layernorm-1p \
+    --squared-relu \
+    --num-layers 32 \
+    --hidden-size 3072 \
+    --ffn-hidden-size 9216 \
+    --num-attention-heads 24 \
+    --group-query-attention \
+    --num-query-groups 8 \
+    --seq-length 4096 \
+    --max-position-embeddings 4096 \
+    --tokenizer-type HuggingFaceTokenizer \
+    --make-vocab-size-divisible-by 1 \
+    --use-mcore-models \
+    --rotary-base 10000 \
+"
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/openai/gpt-oss-120b.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/openai/gpt-oss-120b.sh
new file mode 100644
index 0000000000000000000000000000000000000000..9bc6142375d4c6b1503cc8198965d8697a473a76
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/openai/gpt-oss-120b.sh
@@ -0,0 +1,53 @@
+#!/bin/bash
+
+if [ -z ${HF_MODEL_CKPT} ]; then
+    HF_MODEL_CKPT=openai/gpt-oss-20b
+    TOKENIZER_MODEL=openai/gpt-oss-20b
+else
+    TOKENIZER_MODEL=${HF_MODEL_CKPT}
+fi
+
+# WAR: enable-gpt-oss is a temporary workaround for using the default GPT-OSS config
+MODEL_ARGS=" \
+    --save-interval 100000 \
+    --micro-batch-size 1 \
+    --bf16 \
+    --no-masked-softmax-fusion \
+    --untie-embeddings-and-output-weights \
+    --no-rope-fusion \
+    --normalization RMSNorm \
+    --num-layers 36 \
+    --hidden-size 2880 \
+    --ffn-hidden-size 2880 \
+    --num-attention-heads 64 \
+    --group-query-attention \
+    --num-query-groups 8 \
+    --kv-channels 64 \
+    --num-experts 128 \
+    --moe-ffn-hidden-size 2880 \
+    --moe-router-dtype fp32 \
+    --moe-router-topk 4 \
+    --moe-aux-loss-coeff 0.0 \
+    --moe-token-dispatcher-type alltoall \
+    --moe-router-score-function softmax \
+    --moe-router-load-balancing-type aux_loss \
+    --seq-length 4096 \
+    --max-position-embeddings 40960 \
+    --tokenizer-type HuggingFaceTokenizer \
+    --make-vocab-size-divisible-by 128 \
+    --use-mcore-models \
+    --rotary-percent 1.0 \
+    --rotary-base 150000 \
+    --no-bias-gelu-fusion \
+    --sequence-parallel \
+    --export-force-local-attention \
+    --no-bias-dropout-fusion \
+    --padded-vocab-size 201088 \
+    --quick-geglu \
+    --glu-linear-offset 1.0 \
+    --softmax-type learnable \
+    --window-attn-skip-freq 2 \
+    --enable-gpt-oss \
+    --activation-func-clamp-value 7.0 \
+    --window-size 127,0 \
+"
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/openai/gpt-oss-20b.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/openai/gpt-oss-20b.sh
new file mode 100644
index 0000000000000000000000000000000000000000..601709c847aebb8a007f54ab689a713ad25bcad0
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/post_training/modelopt/conf/openai/gpt-oss-20b.sh
@@ -0,0 +1,53 @@
+#!/bin/bash
+
+if [ -z ${HF_MODEL_CKPT} ]; then
+    HF_MODEL_CKPT=openai/gpt-oss-20b
+    TOKENIZER_MODEL=openai/gpt-oss-20b
+else
+    TOKENIZER_MODEL=${HF_MODEL_CKPT}
+fi
+
+# WAR: enable-gpt-oss is a temporary workaround for using the default GPT-OSS config
+MODEL_ARGS=" \
+    --save-interval 100000 \
+    --micro-batch-size 1 \
+    --bf16 \
+    --no-masked-softmax-fusion \
+    --untie-embeddings-and-output-weights \
+    --no-rope-fusion \
+    --normalization RMSNorm \
+    --num-layers 24 \
+    --hidden-size 2880 \
+    --ffn-hidden-size 2880 \
+    --num-attention-heads 64 \
+    --group-query-attention \
+    --num-query-groups 8 \
+    --kv-channels 64 \
+    --num-experts 32 \
+    --moe-ffn-hidden-size 2880 \
+    --moe-router-dtype fp32 \
+    --moe-router-topk 4 \
+    --moe-aux-loss-coeff 0.0 \
+    --moe-token-dispatcher-type alltoall \
+    --moe-router-score-function softmax \
+    --moe-router-load-balancing-type aux_loss \
+    --seq-length 4096 \
+    --max-position-embeddings 40960 \
+    --tokenizer-type HuggingFaceTokenizer \
+    --make-vocab-size-divisible-by 128 \
+    --use-mcore-models \
+    --rotary-percent 1.0 \
+    --rotary-base 150000 \
+    --no-bias-gelu-fusion \
+    --sequence-parallel \
+    --export-force-local-attention \
+    --no-bias-dropout-fusion \
+    --padded-vocab-size 201088 \
+    --quick-geglu \
+    --glu-linear-offset 1.0 \
+    --softmax-type learnable \
+    --window-attn-skip-freq 2 \
+    --enable-gpt-oss \
+    --activation-func-clamp-value 7.0 \
+    --window-size 127,0 \
+"
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/t5/README.md b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/t5/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..205da1db3702b5b04e69d759d7ee9e381570e669
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/t5/README.md
@@ -0,0 +1,55 @@
+# T5 MODEL
+
+## Table of contents
+- [1. Training Setup](#1-training-setup)
+- [2. Configurations](#2-configurations)
+- [3. Training Results](#3-training-results)
+
+## 1. Training setup
+<a id="markdown-training-setup" name="training-setup"></a>
+To run the model on a Slurm based cluster  
+```
+PYTORCH_IMAGE=nvcr.io/nvidia/pytorch:23.09-py3
+ACCOUNT_NAME="" 
+PARTITION=""
+JOB_NAME=""
+NUM_NODES=1
+CHECKPOINT_PATH="" #<Specify path to checkpoint>
+TENSORBOARD_LOGS_PATH=""#<Specify path to tensorboard log>
+VOCAB_FILE="" #<Specify path to file>/bert-large-cased-vocab.txt
+DATA_PATH="" #<Specify path and file prefix>_text_document
+
+srun -N $NUM_NODES --container-image $PYTORCH_IMAGE --container-mounts "/path/to/data:/path/to/data,/path/to/megatron-lm:/workspace/megatron-lm" --account $ACCOUNT -N 1 -J $JOB_NAME  -p $PARTITION --no-container-mount-home  -c "
+  cd /workspace/megatron-lm
+  ./examples/t5/train_t5_220m_distributed.sh $CHECKPOINT_PATH $TENSORBOARD_LOGS_PATH $VOCAB_FILE $DATA_PATH"
+
+```
+
+## 2. Configurations
+<a id="markdown-configurations" name="configurations"></a>
+The architecture arguments below shows configuration for T5 220M model. 
+
+### 220M 
+```
+       --num-layers 12 \
+       --hidden-size 768 \
+       --num-attention-heads 12 \
+       --kv-channels 64 \
+       --ffn-hidden-size 3072 \
+       --encoder-seq-length 512 \
+       --decoder-seq-length 128 \
+       --max-position-embeddings 512 \
+       --tensor-model-parallel-size 1 \
+       --pipeline-model-parallel-size 1 \
+
+```
+
+
+## 3. Training Results
+<a id="markdown-training-results" name="training-results"></a>
+Below is the training curve for the 220M model on Pile dataset. The training takes 4 days on 32 GPUs, with batch size of 2048. 
+
+Finetuning on SQUAD dataset, the validation result is: 63.44\%
+<p align="center">
+<img src="./t5_mcore_train_curve.png"  width="800" height="400">
+</p>
diff --git a/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/t5/train_t5_220m_distributed.sh b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/t5/train_t5_220m_distributed.sh
new file mode 100644
index 0000000000000000000000000000000000000000..62e6f9db4bd1c3a2d73d455e641708239e1add82
--- /dev/null
+++ b/tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/t5/train_t5_220m_distributed.sh
@@ -0,0 +1,78 @@
+#!/bin/bash
+
+# Runs the "220M" parameter model
+
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+
+GPUS_PER_NODE=8
+# Change for multinode config
+MASTER_ADDR=localhost
+MASTER_PORT=6000
+NUM_NODES=1
+NODE_RANK=0
+WORLD_SIZE=$(($GPUS_PER_NODE*$NUM_NODES))
+
+CHECKPOINT_PATH=$1 #<Specify path>
+TENSORBOARD_DIR=$2 #<Specify path>
+VOCAB_FILE=$3 #<Specify path to file>/bert-large-cased-vocab.txt
+DATA_PATH=$4 #<Specify path and file prefix>_text_document
+
+DISTRIBUTED_ARGS="
+    --nproc_per_node $GPUS_PER_NODE \
+    --nnodes $NUM_NODES \
+    --node_rank $NODE_RANK \
+    --master_addr $MASTER_ADDR \
+    --master_port $MASTER_PORT
+"
+
+T5_ARGS="
+    --encoder-num-layers 12 \
+    --decoder-num-layers 12 \
+    --hidden-size 768 \
+    --num-attention-heads 12 \
+    --kv-channels 64 \
+    --ffn-hidden-size 3072 \
+    --encoder-seq-length 512 \
+    --decoder-seq-length 128 \
+    --max-position-embeddings 512 \
+    --micro-batch-size 64 \
+    --global-batch-size 512 \
+    --lr 0.0001 \
+    --train-iters 1000000 \
+    --lr-decay-iters 1000000 \
+    --lr-decay-style linear \
+    --min-lr 0.00001 \
+    --weight-decay 1e-2 \
+    --lr-warmup-fraction .01 \
+    --clip-grad 1.0 \
+    --bf16 \
+    --vocab-extra-ids 100 \
+    --init-method-std 0.015 \
+    --transformer-impl transformer_engine \
+    --tensor-model-parallel-size 1 \
+    --pipeline-model-parallel-size 1 \
+    --attention-backend auto \
+"
+
+DATA_ARGS="
+    --data-path $DATA_PATH \
+    --vocab-file $VOCAB_FILE \
+    --tokenizer-type BertWordPieceCase \
+    --split 99982,9,9 \
+"
+
+OUTPUT_ARGS="
+    --log-interval 100 \
+    --tensorboard-dir ${TENSORBOARD_DIR} \
+    --save-interval 500 \
+    --eval-interval 1000 \
+    --eval-iters 10
+"
+
+torchrun $DISTRIBUTED_ARGS pretrain_t5.py \
+    $T5_ARGS \
+    $DATA_ARGS \
+    $OUTPUT_ARGS \
+    --distributed-backend nccl \
+    --save $CHECKPOINT_PATH \
+    --load $CHECKPOINT_PATH \