Upload FAI-Bench task files batch 62

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/api-guide/core/datasets.md

@@ -0,0 +1,13 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# datasets package
+
+```{include} ../../../megatron/core/datasets/readme.md
+```

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/api-guide/core/dist_checkpointing.md

@@ -0,0 +1,133 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# dist_checkpointing package
+
+A library for saving and loading the distributed checkpoints.
+A *distributed checkpoint* in Megatron Core uses the ``torch_dist`` format,
+a custom checkpointing mechanism built on top of PyTorch's native
+checkpointing capabilities.
+
+A key property of distributed checkpoints is that a checkpoint saved under one
+parallel configuration (tensor, pipeline, or data parallelism) can be loaded
+under a different parallel configuration. This enables flexible scaling and
+resharding of models across heterogeneous training setups.
+
+Using the library requires defining sharded state_dict dictionaries with functions from  *mapping* and *optimizer* modules.
+Those state dicts can be saved or loaded with a *serialization* module using strategies from *strategies* module.
+
+## Safe Checkpoint Loading
+
+Since **PyTorch 2.6**, the default behavior of `torch.load` is `weights_only=True`.
+This ensures that only tensors and allow-listed classes are loaded, reducing the risk of arbitrary code execution.
+
+If you encounter an error such as:
+
+```bash
+WeightsUnpickler error: Unsupported global: GLOBAL argparse.Namespace was not an allowed global by default.
+```
+
+you can fix it by explicitly allow-listing the missing class in your script:
+
+```python
+import torch, argparse
+
+torch.serialization.add_safe_globals([argparse.Namespace])
+```
+
+## Checkpointing Distributed Optimizer
+
+### Checkpoint Compatibility and Optimizer State Formats
+
+Beginning with **mcore v0.14**, the ``flattened_range`` attribute was removed from ``dist_checkpointing``. As a result:
+
+- Optimizer states saved with mcore versions <= 0.14 can no longer be loaded directly. Loading these legacy optimizer states is not supported because the required sharded metadata is no longer available. If you need to continue training from older checkpoints, refer to the workaround described below.
+- Model weights from older checkpoints remain fully compatible. No extra steps are needed—model weights from checkpoints created by earlier versions load automatically; simply add the ``--no-load-optim`` flag.
+
+### Workaround: Loading legacy optimizer states with ToT MCore
+
+**Step 1: Convert the legacy checkpoint using mcore v0.15.0**
+
+Run a dummy training job with mcore v0.15.0 to re-save the checkpoint with new optimizer states format.
+
+```bash
+MODEL_TRAIN_PARAMS=(
+    # Define model architecture and training parameters here
+)
+OLD_CKPT=/workspace/mcore_ckpt_old
+CONVERTED_CKPT=/workspace/mcore_ckpt_0.15.0
+
+torchrun --nproc_per_node=8 /opt/megatron-lm/pretrain_gpt.py \
+   --save-interval 1 \
+   --eval-interval 1 \
+   --exit-interval 1 \
+   --eval-iters 1 \
+   --use-distributed-optimizer \
+   --save ${CONVERTED_CKPT} \
+   --load ${OLD_CKPT} \
+   --ckpt-format torch_dist \
+   "${MODEL_TRAIN_PARAMS[@]}"
+```
+
+**Step 2: Load the converted checkpoint with ToT MCore**
+
+Use the converted checkpoint as the input for continued training with ToT MCore.
+
+```bash
+MODEL_TRAIN_PARAMS=(
+    # Define model architecture and training parameters here
+)
+NEW_CKPT=/workspace/mcore_ckpt_new
+CONVERTED_CKPT=/workspace/mcore_ckpt_0.15.0
+
+torchrun --nproc_per_node=8 /opt/megatron-lm/pretrain_gpt.py \
+   --use-distributed-optimizer \
+   --save ${NEW_CKPT} \
+   --load ${CONVERTED_CKPT} \
+   --ckpt-format torch_dist \
+   "${MODEL_TRAIN_PARAMS[@]}"
+```
+
+After this step, training can proceed normally using ToT MCore with fully supported optimizer state loading.
+
+## Distributed Optimizer Checkpoint Formats
+
+The refactor of the Distributed Optimizer introduces **two checkpoint formats**:
+
+- dp_reshardable (Default)
+   - Fast save/load performance.
+   - Not reshardable — not possible to change model parallelism when using this format.
+   - Recommended for general training when model parallelism changes are not needed.
+- fully_reshardable
+   - Fully reshardable — supports arbitrary changes in model parallelism.
+   - Slower than dp_reshardable.
+   - Enabled via the ``--dist-ckpt-optim-fully-reshardable`` flag.
+
+### Workflow for Changing Model Parallelism
+
+You can combine formats to optimize both flexibility and performance:
+
+   1. Train using ``dp_reshardable`` (default) for faster checkpointing.
+   2. When you need to change model parallelism:
+
+      - Stop training.
+      - Change model parallelism for train config.
+      - Resume training with ``--dist-ckpt-optim-fully-reshardable``.
+
+   3. Save at least one checkpoint under the new model parallel configuration.
+   4. (Optional) To continue the training with updated model parallelism and better checkpointing performance, stop training and switch back to ``dp_reshardable`` format by removing ``--dist-ckpt-optim-fully-reshardable``.
+
+## Subpackages
+
+```{toctree}
+:maxdepth: 4
+
+dist_checkpointing.strategies
+```
+

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/api-guide/core/dist_checkpointing.strategies.md

@@ -0,0 +1,16 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# dist_checkpointing.strategies package
+
+Package defining different checkpoint formats (backends) and saving/loading algorithms (strategies).
+
+Strategies can be used for implementing new checkpoint formats or implementing new (more optimal for a given use case) ways of saving/loading of existing formats.
+Strategies are passed to `dist_checkpointing.load` and `dist_checkpointing.save` functions and control the actual saving/loading procedure.
+

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/api-guide/core/distributed.md

@@ -0,0 +1,19 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# distributed package
+
+This package contains various utilities to finalize model weight gradients
+on each rank before the optimizer step. This includes a distributed data
+parallelism wrapper to all-reduce or reduce-scatter the gradients across
+data-parallel replicas, and a `finalize_model_grads` method to
+synchronize gradients across different parallelism modes (e.g., 'tied'
+layers on different pipeline stages, or gradients for experts in a MoE on
+different ranks due to expert parallelism).
+

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/api-guide/core/fusions.md

@@ -0,0 +1,20 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# fusions package
+
+This package provides modules that provide commonly fused
+operations. Fusing operations improves compute efficiency by
+increasing the amount of work done each time a tensor is read from
+memory. To perform the fusion, modules in this either rely on PyTorch
+functionality for doing just-in-time compilation
+(i.e. `torch.jit.script` in older PyTorch versions of `torch.compile`
+in recent versions), or call into custom kernels in external libraries
+such as Apex or TransformerEngine.
+

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/api-guide/core/index.md

@@ -0,0 +1,25 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# Core APIs
+
+Low-level API reference for core Megatron components.
+
+```{toctree}
+:maxdepth: 2
+
+transformer
+tensor_parallel
+pipeline_parallel
+fusions
+distributed
+datasets
+dist_checkpointing
+dist_checkpointing.strategies
+```

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/api-guide/core/pipeline_parallel.md

@@ -0,0 +1,16 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# pipeline_parallel package
+
+This package contains implementations for two different pipeline parallelism
+schedules (one without interleaving and one with interleaving, see [Efficient Large-Scale Language Model Training on GPU Clusters Using Megatron-LM](https://arxiv.org/abs/2104.04473)
+for details), and a default no-pipelining schedule. It also contains methods
+for the point-to-point communication that is needed between pipeline stages.
+

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/api-guide/core/tensor_parallel.md

@@ -0,0 +1,17 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# tensor_parallel package
+
+This package contains an implementation for tensor parallelism in transformer
+models (see [Megatron-LM: Training Multi-Billion Parameter Language Models
+Using Model Parallelism](https://arxiv.org/abs/1909.08053) and [Reducing
+Activation Recomputation in Large Transformer Models](https://arxiv.org/abs/2205.05198)
+for details).
+

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/api-guide/core/transformer.md

@@ -0,0 +1,19 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# transformer package
+
+The `transformer` package provides a customizable and configurable
+implementation of the transformer model architecture. Each component
+of a transformer stack, from entire layers down to individual linear
+layers, can be customized by swapping in different PyTorch modules
+using the "spec" parameters. The
+configuration of the transformer (hidden size, number of layers,
+number of attention heads, etc.) is provided via a `TransformerConfig`
+object.

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/api-guide/index.md

@@ -0,0 +1,20 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# API Guide
+
+API reference documentation for Megatron Core components.
+
+```{toctree}
+:maxdepth: 3
+
+models/index
+core/index
+internal/index
+```

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/api-guide/internal/index.md

@@ -0,0 +1,19 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# Internal Utilities
+
+Internal utility APIs.
+
+```{toctree}
+:maxdepth: 2
+
+num_microbatches_calculator
+optimizer_param_scheduler
+```

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/api-guide/internal/num_microbatches_calculator.md

@@ -0,0 +1,13 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# Microbatches Calculator
+
+This api is used to calculate the number of microbatches required to fit a given model on a given batch size.
+

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/api-guide/internal/optimizer_param_scheduler.md

@@ -0,0 +1,13 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# Optimizer Parameters Scheduler
+
+This api is used to calculate the learning rate and weight decay for the optimizer.
+

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/api-guide/models/index.md

@@ -0,0 +1,21 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# Model APIs
+
+API reference for Megatron Core model implementations.
+
+```{toctree}
+:maxdepth: 2
+
+models
+models.gpt
+models.bert
+models.t5
+```

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/api-guide/models/models.bert.md

@@ -0,0 +1,13 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# models.bert package
+
+Useful package for training bert and bert like encoder only models. It optionally comes with a binary head that can be used for classification tasks .
+

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/api-guide/models/models.gpt.md

@@ -0,0 +1,13 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# models.gpt package
+
+This is the implementation of the popular GPT model. It supports several features like model parallelization (Tensor Parallel, Pipeline Parallel, Data Parallel) , mixture of experts, FP8 , Distributed optimizer etc. We are constantly adding new features. So be on the lookout or raise an issue if you want to have something added.
+

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/api-guide/models/models.md

@@ -0,0 +1,23 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# models package
+
+This package contains most of the popular LLMs . Currently we have support for GPT, Bert, and T5 . This is an ever growing list so keep an eye out.
+
+## Subpackages
+
+```{toctree}
+:maxdepth: 4
+
+models.gpt
+models.t5
+models.bert
+```
+

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/api-guide/models/models.t5.md

@@ -0,0 +1,11 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# models.t5 package
+

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/api-guide/router_replay.md

@@ -0,0 +1,186 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# Design Document: MoE Router Replay Feature
+
+## 1. Overview
+
+This document provides a detailed description of the "Router Replay" feature implemented within the Megatron-LM Core for Mixture-of-Experts (MoE) models.
+
+This feature is designed to enhance determinism and analyzability in MoE model training and inference. It enables the model to load routing decisions from a predefined file and enforce their use during the forward pass, thereby bypassing the real-time routing computation.
+
+## 2. Motivation
+
+*   **Determinism & Reproducibility**: In distributed training, MoE routing decisions can exhibit minor variations due to factors like floating-point precision. By replaying a fixed routing table, the MoE computation path is guaranteed to be identical across runs, which facilitates debugging and reproducing experimental results.
+*   **Performance Profiling**: The router's own computation (e.g., logits calculation, top-k selection) incurs overhead. In replay mode, this part of the computation can be completely skipped, allowing for more precise isolation and profiling of performance bottlenecks within the Expert Layers themselves.
+*   **Debugging Aid**: When issues arise in the model, fixing the routing decisions helps to isolate variables, making it easier to determine whether the problem lies with the routing mechanism or the expert computations.
+
+## 3. Design and Architecture
+
+The design follows the principles of being non-intrusive and on-demand, with the core idea of activating the replay logic only when explicitly requested by the user.
+
+*   **Core Components**:
+    *   `RouterReplay` (located in `megatron/core/transformer/moe/router_replay.py`): A utility class for replaying MoE routing decisions. When enabled via the `moe_enable_routing_replay` flag, a separate instance of `RouterReplay` is created for each MoE layer's router. Each instance is responsible for loading routing data and providing the deterministic routing decisions for its corresponding layer during the forward pass.
+    *   `moe_enable_routing_replay` (located in `megatron/core/transformer/transformer_config.py`): A boolean global configuration flag that serves as the sole entry point for enabling this feature.
+
+*   **Workflow**:
+    The feature supports different modes, such as recording and replaying, controlled by a `RouterReplayAction`.
+
+    1.  **Enabling the Feature**: The user sets `moe_enable_routing_replay` to `True` in the model configuration.
+    2.  **Initialization**: When `moe_enable_routing_replay` is true, each `TopKRouter` creates its own `RouterReplay` instance.
+    3.  **Mode Configuration**: The user must programmatically set the desired router replay action (e.g., `record`, `forward_replay`, `backward_replay`) on the `RouterReplay` instances.
+    4.  **Execution Flow (within a mini-batch)**:
+        *   **Forward Pass**:
+            *   For each micro-batch, the `topk_routing_with_score_function` checks the `router_replay_action`.
+            *   **In `record` mode**: The dynamically computed `top-k` expert indices are captured and stored.
+            *   **In `forward_replay` mode**: The function retrieves pre-loaded expert indices from `target_topk_idx`. These indices are used for the forward computation and are also appended to the `replay_backward_list` to prepare for the backward pass.
+        *   **Backward Pass**:
+            *   For each micro-batch (processed in reverse order in pipeline parallelism), the `router_replay_action` is checked again.
+            *   **In `backward_replay` mode**: The function retrieves the expert indices for the corresponding micro-batch by popping them from the `replay_backward_list`. This mode is intended for training recomputation (e.g., activation checkpointing and pipeline recompute) so the same routing decisions are used during recompute/backward as in forward, ensuring determinism and correctness.
+
+## 4. Implementation Details
+
+The implementation cleanly separates the replay logic from the router's core computation.
+
+*   **`megatron/core/transformer/transformer_config.py`**:
+    *   Adds the configuration option `moe_enable_routing_replay: bool = False`.
+
+*   **`megatron/core/transformer/moe/moe_utils.py`**:
+    *   Introduces the `RouterReplay` class to manage the state for recording and replaying routing decisions for a single MoE layer.
+        *   `target_topk_idx`: An attribute holding the expert indices for the current micro-batch during forward replay mode.
+        *   `recorded_topk_idx`: An attribute for storing the computed expert indices when in record mode.
+        *   `replay_backward_list`: A list that accumulates the `top-k` indices used during the forward passes of a mini-batch. This list is consumed in FIFO order during the backward pass to ensure correctness under pipeline parallelism.
+        *   `set_target_indices()`: A method to load the replay indices into `target_topk_idx` for the forward pass.
+        *   `record_indices()`: A method to save the computed indices.
+    *   The `topk_routing_with_score_function` is modified to contain the core logic. It checks the `router_replay_action` on the `router_replay` instance and accordingly performs one of the following actions: computes and records indices, replays indices from `target_topk_idx` (for forward), replays indices from `replay_backward_list` (for backward), or falls through to the default dynamic routing.
+
+### Training recompute usage
+
+- During forward replay, `set_target_indices()` prepares `replay_backward_list` so each micro-batch’s indices are available for recomputation.
+- During recompute/backward, set action to `REPLAY_BACKWARD` so indices are consumed in FIFO order to mirror the forward sequence.
+
+## 5. Usage Guide
+
+1.  **Enable & Instantiate**
+    - Create one `RouterReplay` instance per MoE router layer when building the model.
+    - Optionally use the global helpers to set/clear actions across all layers.
+2.  **Record Routing Decisions**
+    - Set action: `RouterReplay.set_global_router_replay_action(RouterReplayAction.RECORD)`.
+    - Run the model; retrieve per-layer indices via `RouterReplay.get_recorded_data()` and persist.
+3.  **Forward Replay**
+    - Load indices and distribute: `RouterReplay.set_replay_data(list_of_tensors)`.
+    - Set action: `RouterReplay.set_global_router_replay_action(RouterReplayAction.REPLAY_FORWARD)`.
+    - Run the model; dynamic top‑k is bypassed and target indices are used.
+4.  **Backward Replay**
+    - For training recomputation (activation checkpointing or pipeline recompute), set action: `REPLAY_BACKWARD` during recomputation.
+    - Per micro‑batch indices are consumed from `replay_backward_list` in FIFO order.
+5.  **Cleanup**
+    - Use `RouterReplay.clear_global_indices()`, `RouterReplay.clear_global_router_replay_action()`, and `RouterReplay.clear_global_router_replay_instances()` to restore default behavior and prevent memory leaks.
+
+### Quick usage with `topk_routing_with_score_function`
+
+```python
+import torch
+from megatron.core.transformer.moe.router_replay import RouterReplay, RouterReplayAction
+from megatron.core.transformer.moe.moe_utils import topk_routing_with_score_function
+
+rr = RouterReplay()
+
+# Record
+RouterReplay.set_global_router_replay_action(RouterReplayAction.RECORD)
+logits = torch.randn(8, 16)
+probs_rec, routing_map_rec = topk_routing_with_score_function(
+    logits=logits, topk=2, use_pre_softmax=False, score_function="softmax", router_replay=rr,
+)
+recorded = rr.get_recorded_indices()
+torch.save(recorded, "/tmp/replay.pt")
+
+# Forward replay
+rr.clear_router_replay_action()
+rr.set_router_replay_action(RouterReplayAction.REPLAY_FORWARD)
+target = torch.load("/tmp/replay.pt")
+rr.set_target_indices(target)
+probs_rep, routing_map_rep = topk_routing_with_score_function(
+    logits=logits, topk=2, use_pre_softmax=False, score_function="softmax", router_replay=rr,
+)
+
+RouterReplay.clear_global_router_replay_action()
+RouterReplay.clear_global_indices()
+RouterReplay.clear_global_router_replay_instances()
+```
+
+## 6. Minimal Demo
+
+Here is a minimal code example showing how to use RouterReplay for recording and replaying:
+
+```python
+import torch
+import torch.distributed as dist
+from megatron.core.transformer.transformer_config import TransformerConfig
+from megatron.core.transformer.moe.router import TopKRouter
+from megatron.core.transformer.moe.router_replay import RouterReplay, RouterReplayAction
+
+
+# Initialize distributed training
+if not dist.is_initialized():
+    dist.init_process_group(backend="nccl")
+
+# Create a transformer config with RouterReplay enabled
+config = TransformerConfig(
+    num_experts=8,
+    expert_model_parallel_size=1,
+    num_top_k=2,
+    moe_enable_routing_replay=True
+)
+
+# Create a TopKRouter instance
+router = TopKRouter(config)
+
+# Generate sample input (batch_size, sequence_length, hidden_size)
+logits = torch.randn(16, 32, 8).to(torch.cuda.current_device())
+
+# -----------------
+# 1. Recording Mode
+# -----------------
+print("=== Recording Mode ===")
+# Set global router replay action to RECORD
+RouterReplay.set_global_router_replay_action(RouterReplayAction.RECORD)
+
+# Perform routing
+routing_output = router.forward(logits)
+print(f"Recorded top-k indices shape: {routing_output.top_k_idx.shape}")
+
+# -----------------
+# 2. Forward Replay Mode
+# -----------------
+print("\n=== Forward Replay Mode ===")
+# Save recorded indices to a file
+torch.save(routing_output.top_k_idx, "/tmp/replay.pt")
+
+# Load indices from file and set as target for replay
+replay_indices = torch.load("/tmp/replay.pt")
+for router_instance in RouterReplay.global_router_replay_instances:
+    router_instance.target_topk_idx = replay_indices
+
+# Set global router replay action to REPLAY_FORWARD
+RouterReplay.set_global_router_replay_action(RouterReplayAction.REPLAY_FORWARD)
+
+# Perform routing again - this will use the replayed indices
+replay_routing_output = router.forward(logits)
+print(f"Replayed top-k indices shape: {replay_routing_output.top_k_idx.shape}")
+print(f"Are indices the same? {torch.equal(routing_output.top_k_idx, replay_routing_output.top_k_idx)}")
+
+
+# Clean up
+RouterReplay.clear_global_router_replay_action()
+RouterReplay.clear_global_indices()
+RouterReplay.clear_global_router_replay_instances()
+if dist.is_initialized():
+    dist.destroy_process_group()
+```

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/get-started/install.md

@@ -0,0 +1,123 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# Installation
+
+## System Requirements
+
+### Hardware
+
+- **Recommended**: NVIDIA Turing architecture or later
+- **FP8 Support**: Requires NVIDIA Hopper, Ada, or Blackwell GPUs
+
+### Software
+
+- **Python**: >= 3.10 (3.12 recommended)
+- **PyTorch**: >= 2.6.0
+- **CUDA Toolkit**: Latest stable version
+
+
+## Prerequisites
+
+Install [uv](https://docs.astral.sh/uv/), a fast Python package installer:
+
+```bash
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+
+
+## Option A: Pip Install (Recommended)
+
+Install the latest stable release from PyPI:
+
+```bash
+uv pip install megatron-core
+```
+
+To include optional training dependencies (Weights & Biases, SentencePiece, HF Transformers):
+
+```bash
+uv pip install "megatron-core[training]"
+```
+
+For all extras including [Transformer Engine](https://github.com/NVIDIA/TransformerEngine):
+
+```bash
+uv pip install --group build
+uv pip install --no-build-isolation "megatron-core[training,dev]"
+```
+
+```{note}
+`--no-build-isolation` requires build dependencies to be pre-installed in the environment. `torch` is needed because several `[dev]` packages (`mamba-ssm`, `nv-grouped-gemm`, `transformer-engine`) import it at build time to compile CUDA kernels. Expect this step to take **20+ minutes** depending on your hardware. If you prefer pre-built binaries, the [NGC Container](#option-c-ngc-container) ships with these pre-compiled.
+```
+
+```{warning}
+Building from source can consume a large amount of memory. By default the build runs one compiler job per CPU core, which may cause out-of-memory failures on machines with many cores. To limit parallel compilation jobs, set the `MAX_JOBS` environment variable before installing (e.g. `MAX_JOBS=4`).
+```
+
+```{tip}
+For a lighter set of development dependencies without Transformer Engine and ModelOpt, use `[lts]` instead of `[dev]`: `uv pip install --no-build-isolation "megatron-core[training,lts]"`. The `[lts]` and `[dev]` extras are mutually exclusive.
+```
+
+To clone the repository for examples:
+
+```bash
+git clone https://github.com/NVIDIA/Megatron-LM.git
+```
+
+
+## Option B: Install from Source
+
+For development or to run the latest unreleased code:
+
+```bash
+git clone https://github.com/NVIDIA/Megatron-LM.git
+cd Megatron-LM
+uv pip install -e .
+```
+
+To install with all development dependencies (includes Transformer Engine, requires pre-installed build deps):
+
+```bash
+uv pip install --group build
+uv pip install --no-build-isolation -e ".[training,dev]"
+```
+
+```{tip}
+If the build runs out of memory, limit parallel compilation jobs with `MAX_JOBS=4 uv pip install --no-build-isolation -e ".[training,dev]"`.
+```
+
+
+## Option C: NGC Container
+
+For a pre-configured environment with all dependencies pre-installed (PyTorch, CUDA, cuDNN, NCCL, Transformer Engine), use the [PyTorch NGC Container](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/pytorch).
+
+We recommend using the **previous month's** NGC container rather than the latest one to ensure compatibility with the current Megatron Core release and testing matrix.
+
+```bash
+docker run --gpus all -it --rm \
+  -v /path/to/dataset:/workspace/dataset \
+  -v /path/to/checkpoints:/workspace/checkpoints \
+  -e PIP_CONSTRAINT= \
+  nvcr.io/nvidia/pytorch:26.01-py3
+```
+
+```{note}
+The NGC PyTorch container constrains the Python environment globally via `PIP_CONSTRAINT`. The `-e PIP_CONSTRAINT=` flag above unsets this so that Megatron Core and its dependencies install correctly.
+```
+
+Then install Megatron Core inside the container (torch is already available in the NGC image):
+
+```bash
+pip install uv
+uv pip install --no-build-isolation "megatron-core[training,dev]"
+```
+
+
+You are now ready to run training. See [Your First Training Run](quickstart.md) for next steps.

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/get-started/overview.md

@@ -0,0 +1,93 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# Overview
+
+Megatron-Core and Megatron-LM are open-source tools that are typically used together to train LLMs at scale across GPUs. Megatron-Core expands the capability of Megatron-LM. Megatron Bridge connects Megatron-Core and Megatron-LM to other popular training models, such as Hugging Face.
+
+## Megatron Core
+
+NVIDIA Megatron Core is a library of essential building blocks for highly efficient large-scale generative AI training. It can be used to train models with unparalleled speed at scale across thousands of GPUs. It provides an extensive set of tools for multimodal and speech AI. It expands Megatron LM capabilities.
+
+Megatron-Core contains GPU-optimized techniques featuring advanced parallelism strategies, optimizations like FP8 training, and support for the latest LLM, MoE, and multimodal architectures. It abstracts these techniques into composable and modular APIs.
+
+Megatron-Core is compatible with all NVIDIA Tensor Core GPUs and popular LLM architectures such as GPT, BERT, T5, and RETRO.
+
+
+**Composable library** with GPU-optimized building blocks for custom training frameworks.
+
+**Best for:**
+
+- **Framework developers** building on top of modular and optimized components
+- **Research teams** needing custom training loops, optimizers, or data pipelines
+- **ML engineers** requiring fault-tolerant training pipelines
+
+**What you get:**
+
+- Composable transformer building blocks (attention, MLP)
+- Advanced parallelism strategies (TP, PP, DP, EP, CP)
+- Pipeline schedules and distributed optimizers
+- Mixed precision support (FP16, BF16, FP8)
+- GPU-optimized kernels and memory management
+- High-performance dataloaders and dataset utilities
+- Model architectures (LLaMA, Qwen, GPT, Mixtral, Mamba)
+
+## Megatron-LM
+
+Megatron-LM is a reference implementation, with a lightweight large-scale LLM training framework. It offers a customizable native PyTorch training loop with fewer abstraction layers. It was designed for scaling transformer models to the multi-billion and trillion-parameter regimes under realistic memory and compute constraints. **It serves as a straightforward entry point for exploring Megatron-Core.**
+
+It uses advanced parallelization techniques including model parallelism (tensor and pipeline), to allow models with billions of parameters to fit and train across large GPU clusters. It enables breakthroughs in large-scale NLP tasks. It splits model computations across many GPUs, overcoming single-GPU memory limits for training huge models, like GPT-style transformers.  
+
+
+**Reference implementation** that includes Megatron Core plus everything needed to train models.
+
+**Best for:**
+
+- **Training state-of-the-art foundation models** at scale with cutting-edge performance on latest NVIDIA hardware
+- **Research teams** exploring new architectures and training techniques
+- **Learning distributed training** concepts and best practices
+- **Quick experimentation** with proven model configurations
+
+**What you get:**
+
+- Pre-configured training scripts for GPT, LLaMA, DeepSeek, Qwen, and more.
+- End-to-end examples from data prep to evaluation
+- Research-focused tools and utilities
+
+
+
+## Megatron Bridge
+
+Megatron Bridge provides out-of-the-box bridges and training recipes for models built on top of base model architectures from Megatron Core.  
+
+Megatron Bridge provides a robust, parallelism-aware pathway to convert models and checkpoints. This bidirectional converter performs on-the-fly, model-parallel-aware, per-parameter conversion, and full in-memory loading.
+
+After training or modifying a Megatron model, you can convert it again for deployment or sharing.  
+
+[Megatron Bridge](https://github.com/NVIDIA-NeMo/Megatron-Bridge)
+
+
+
+## Ecosystem Libraries
+
+**Libraries used by Megatron Core:**
+
+- **[Megatron Energon](https://github.com/NVIDIA/Megatron-Energon)** - Multi-modal data loader (text, images, video, audio) with distributed loading and dataset blending
+- **[Transformer Engine](https://github.com/NVIDIA/TransformerEngine)** - Optimized kernels and FP8 mixed precision support
+- **[Resiliency Extension (NVRx)](https://github.com/NVIDIA/nvidia-resiliency-ext)** - Fault tolerant training with failure detection and recovery
+
+**Libraries using Megatron Core:**
+
+- **[Megatron Bridge](https://github.com/NVIDIA-NeMo/Megatron-Bridge)** - Training library with bidirectional Hugging Face ↔ Megatron checkpoint conversion, flexible training loops, and production-ready recipes
+- **[NeMo RL](https://github.com/NVIDIA-NeMo/RL)** - Scalable toolkit for efficient reinforcement learning with RLHF, DPO, and other post-training methods
+- **[NeMo Framework](https://docs.nvidia.com/nemo-framework/user-guide/latest/overview.html)** - Enterprise framework with cloud-native support and end-to-end examples
+- **[Model Optimizer (ModelOpt)](https://github.com/NVIDIA/Model-Optimizer)** - Model optimization toolkit for quantization, pruning, distillation, speculative decoding, and more. Checkout end-to-end examples in [examples/post_training/modelopt](https://github.com/NVIDIA/Megatron-LM/tree/main/examples/post_training/modelopt).
+
+**Compatible with:** [Hugging Face Accelerate](https://github.com/huggingface/accelerate), [Colossal-AI](https://github.com/hpcaitech/ColossalAI), [DeepSpeed](https://github.com/microsoft/DeepSpeed)
+

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/get-started/quickstart.md

@@ -0,0 +1,68 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# Your First Training Run
+
+This guide walks you through running your first training jobs with Megatron Core. Make sure you have completed [installation](install.md) before proceeding.
+
+## Simple Training Example
+
+Run a minimal distributed training loop with mock data on 2 GPUs:
+
+```bash
+torchrun --nproc_per_node=2 examples/run_simple_mcore_train_loop.py
+```
+
+## LLaMA-3 Training Example
+
+Train a LLaMA-3 8B model with FP8 precision on 8 GPUs using mock data:
+
+```bash
+./examples/llama/train_llama3_8b_h100_fp8.sh
+```
+
+## Data Preparation
+
+To train on your own data, Megatron expects preprocessed binary files (`.bin` and `.idx`).
+
+### 1. Prepare a JSONL File
+
+Each line should contain a `text` field:
+
+```json
+{"text": "Your training text here..."}
+{"text": "Another training sample..."}
+```
+
+### 2. Preprocess the Data
+
+```bash
+python tools/preprocess_data.py \
+    --input data.jsonl \
+    --output-prefix processed_data \
+    --tokenizer-type HuggingFaceTokenizer \
+    --tokenizer-model /path/to/tokenizer.model \
+    --workers 8 \
+    --append-eod
+```
+
+### Key Arguments
+
+- `--input`: Path to input JSON/JSONL file
+- `--output-prefix`: Prefix for output binary files (.bin and .idx)
+- `--tokenizer-type`: Tokenizer type (`HuggingFaceTokenizer`, `GPT2BPETokenizer`, etc.)
+- `--tokenizer-model`: Path to tokenizer model file
+- `--workers`: Number of parallel workers for processing
+- `--append-eod`: Add end-of-document token
+
+## Next Steps
+
+- Explore [Parallelism Strategies](../user-guide/parallelism-guide.md) to scale your training
+- Learn about [Data Preparation](../user-guide/data-preparation.md) best practices
+- Check out [Advanced Features](../user-guide/features/index.md) for advanced capabilities

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/get-started/releasenotes.md

@@ -0,0 +1,19 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# Release Notes
+
+
+## Roadmaps
+
+Stay up-to-date with our development roadmaps and planned features:
+
+- **[MoE Q3-Q4 2025 Roadmap](https://github.com/NVIDIA/Megatron-LM/issues/1729)** - Comprehensive MoE feature development including DeepSeek-V3, Qwen3, advanced parallelism, FP8 optimizations, and Blackwell enhancements
+- **[GPT-OSS Implementation Tracker](https://github.com/NVIDIA/Megatron-LM/issues/1739)** - Advanced features including YaRN RoPE scaling, attention sinks, and custom activation functions
+

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/models/index.md

@@ -0,0 +1,26 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# Supported Models
+
+Megatron Core supports a wide range of language and multimodal models with optimized implementations for large-scale training.
+
+## Model Conversion
+
+For converting HuggingFace models to Megatron format, use [Megatron Bridge](https://github.com/NVIDIA-NeMo/Megatron-Bridge), the official standalone converter. Megatron Bridge supports an extensive list of models including LLaMA, Mistral, Mixtral, Qwen, DeepSeek, Gemma, Phi, Nemotron, and many more.
+
+See the [Megatron Bridge supported models list](https://github.com/NVIDIA-NeMo/Megatron-Bridge?tab=readme-ov-file#supported-models) for the complete and up-to-date list of supported models.
+
+```{toctree}
+:maxdepth: 1
+
+llms
+multimodal
+../llama_mistral
+```

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/models/llms.md

@@ -0,0 +1,59 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# Language Models
+
+Megatron Core supports the following language model architectures for large-scale training.
+
+## Converting HuggingFace Models
+
+Use [**Megatron Bridge**](https://github.com/NVIDIA-NeMo/Megatron-Bridge) to convert HuggingFace models to Megatron format. Megatron Bridge is the official standalone converter with support for an extensive list of models including LLaMA, Mistral, Mixtral, Qwen, DeepSeek, Gemma, Phi, Nemotron, and many more.
+
+See the [Megatron Bridge supported models list](https://github.com/NVIDIA-NeMo/Megatron-Bridge?tab=readme-ov-file#supported-models) for the complete and up-to-date list.
+
+## Decoder-Only Models
+
+| Model | Description | Key Features |
+|-------|-------------|--------------|
+| **GPT** | Generative Pre-trained Transformer | Standard autoregressive LM, foundational architecture |
+| **LLaMA** | Meta's LLaMA family | Efficient architecture with RoPE, SwiGLU, RMSNorm |
+| **Mistral** | Mistral AI models | Sliding window attention, efficient inference |
+| **Mixtral** | Sparse Mixture-of-Experts | 8x7B MoE architecture for efficient scaling |
+| **Qwen** | Alibaba's Qwen series | HuggingFace integration, multilingual support |
+| **Mamba** | State Space Model | Subquadratic sequence length scaling, efficient long context |
+
+## Encoder-Only Models
+
+| Model | Description | Key Features |
+|-------|-------------|--------------|
+| **BERT** | Bidirectional Encoder Representations | Masked language modeling, classification tasks |
+
+## Encoder-Decoder Models
+
+| Model | Description | Key Features |
+|-------|-------------|--------------|
+| **T5** | Text-to-Text Transfer Transformer | Unified text-to-text framework, sequence-to-sequence |
+
+## Example Scripts
+
+Training examples for these models can be found in the `examples/` directory:
+- `examples/gpt3/` - GPT-3 training scripts
+- `examples/llama/` - LLaMA training scripts
+- `examples/mixtral/` - Mixtral MoE training
+- `examples/mamba/` - Mamba training scripts
+- `examples/bert/` - BERT training scripts
+- `examples/t5/` - T5 training scripts
+
+## Model Implementation
+
+All language models are built using Megatron Core's composable transformer blocks, enabling:
+- Flexible parallelism strategies (TP, PP, DP, EP, CP)
+- Mixed precision training (FP16, BF16, FP8)
+- Distributed checkpointing
+- Efficient memory management

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

@@ -0,0 +1,70 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# Multimodal Models
+
+Megatron Core supports multimodal models that combine language with vision, audio, and other modalities for comprehensive multimodal understanding.
+
+## MIMO: Multimodal In/Out Framework
+
+**MIMO (Multimodal In/Out Model)** is an experimental framework in Megatron Core that supports arbitrary combinations of modalities including vision, audio, and text. MIMO provides a flexible architecture for building custom multimodal models.
+
+> **Note**: MIMO is experimental and under active development. The API may change in future releases.
+
+**Key Features:**
+- Arbitrary modality combinations (vision, audio, text, etc.)
+- Flexible encoder architecture for different input modalities
+- Unified embedding space across modalities
+- Support for both vision-language and audio-vision-language models
+
+See [examples/mimo](https://github.com/NVIDIA/Megatron-LM/tree/main/examples/mimo) for training scripts and examples.
+
+## Vision-Language Models
+
+| Model | Description | Vision Encoder | Language Model |
+|-------|-------------|----------------|----------------|
+| **LLaVA** | Visual instruction tuning | CLIP ViT-L/14 | Mistral-7B / LLaMA |
+| **NVLM** | NVIDIA Vision-Language Model | CLIP / Custom ViT | LLaMA-based |
+| **LLaMA 3.1 Nemotron Nano VL** | Efficient multimodal model | Vision Transformer | LLaMA 3.1 8B |
+
+## Vision Encoders
+
+| Model | Description | Key Features |
+|-------|-------------|--------------|
+| **CLIP ViT** | OpenAI's CLIP Vision Transformer | Image-text alignment, multiple scales (L/14@336px) |
+| **RADIO** | Resolution-Agnostic Dynamic Image Optimization | Flexible resolution handling, efficient vision encoding |
+
+## Diffusion Models
+
+For multimodal diffusion models (image generation, text-to-image, etc.), see [NeMo Diffusion Models](https://github.com/NVIDIA-NeMo/NeMo/tree/main/nemo/collections/diffusion). NeMo provides production-ready implementations of:
+- Stable Diffusion variants
+- Text-to-image generation
+- Image-to-image translation
+- ControlNet and other conditioning mechanisms
+
+## Multimodal Features
+
+- **Image-Text Alignment**: Pre-training on image-caption pairs
+- **Visual Instruction Tuning**: Fine-tuning on instruction-following datasets
+- **Flexible Vision Encoders**: Support for different ViT architectures and resolutions
+- **Combined Checkpointing**: Unified checkpoints combining vision and language models
+- **Efficient Training**: Full parallelism support (TP, PP, DP) for both vision and language components
+
+## Example Scripts
+
+Multimodal training examples can be found in the following directories:
+
+**MIMO Framework:**
+- `examples/mimo/` - Multimodal In/Out training with support for vision-language and audio-vision-language models
+
+**Specific Multimodal Models:**
+- `examples/multimodal/` - LLaVA-style training with Mistral + CLIP
+- `examples/multimodal/nvlm/` - NVLM training scripts
+- `examples/multimodal/llama_3p1_nemotron_nano_vl_8b_v1/` - Nemotron VL training
+- `examples/multimodal/radio/` - RADIO vision encoder integration

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/user-guide/features/custom_fsdp.md

@@ -0,0 +1,195 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# Megatron FSDP
+
+**NOTE: In M-Core 0.14, the custom FSDP refactored its checkpoint implementation to use DTensor-based torch distributed checkpointing. The custom FSDP was also renamed Megatron FSDP. The relevant sections of this document are no longer applicable.**
+
+## How to use ?
+
+Add these flag to enable MCore custom FSDP.
+
+```bash
+--use-megatron-fsdp
+--data-parallel-sharding-strategy optim_grads_params
+--no-gradient-accumulation-fusion
+--use-distributed-optimizer
+```
+
+For a practical guide covering required configurations, checkpoint conversion, and example scripts, see the [Megatron-FSDP User Guide](../../discussions/megatron-fsdp-user-guide/megatron-fsdp-user-guide.md).
+
+## Key Features
+
+- **Sharding Strategy**: Efficiently shards optimizer states, gradients, and parameters to reduce memory consumption.
+- **Communication and Computation Overlap**: Optimized to enable concurrent execution of communication and computation, enhancing overall efficiency.
+- **Supports automatic mixed precision training**: Compatible with BF16 O1/O2/O3 recipes, as well as FP8 compute with FP32 parameters and FP8 parameter training, allowing for flexible precision configurations.
+- **Tensor Parallelism (TP), Expert Parallelism (EP) and Context Parallelism (CP)**: Compatible with TP, EP and CP configurations, enabling efficient scaling of large language models.
+- **Distributed Model Initialization with Meta Device**: Allows model initialization using meta device, followed by layer-by-layer initialization of distributed model weight buffers via the `Module.reset_parameters` API, facilitating the initialization of extremely large models.
+
+## Configuration Recommendations
+
+### 1. Disable `CUDA_DEVICE_MAX_CONNECTIONS`
+
+To ensure full parallelization of FSDP communication and computation, disable the CUDA_DEVICE_MAX_CONNECTIONS environment variable. This step avoids potential bubble in CUDA stream. (But it may slow down TP and CP to some extent.)
+
+```bash
+unset CUDA_DEVICE_MAX_CONNECTIONS
+```
+
+### 2. Add `--calculate-per-token-loss`
+
+For gradients sharding mode optimization, include the `--calculate-per-token-loss` flag in your training script. This improves performance by reducing the frequency of gradient scaling, which is also a sizable drain on SM resources.
+
+## Design of Custom FSDP
+
+### 1. Overview
+
+The custom Fully Sharded Data Parallelism (FSDP) implementation in Megatron-Core is specifically designed to optimize memory consumption and performance for large language models. The core design principles include:
+
+ - **Optimized for Large Language Models**: This custom FSDP implementation is tailored to efficiently scale with models containing billions of parameters, ensuring seamless execution and training of massive models.
+ - **Efficient Memory Consumption**: By strategically sharding optimizer states, gradients, and model parameters, the custom FSDP significantly reduces memory usage. This approach enables the training of models that would otherwise be too large to fit in memory.
+ - **Efficient Workflow & Overlapping Communication and Computation**: The implementation is engineered to minimize the number of communication steps required during training. It maximizes the overlap between communication and computation, thereby enhancing overall training efficiency and reducing latency.
+ - **Support for MCore's Efficient Training Methods**: The custom FSDP seamlessly integrates with Megatron-Core's advanced parallelism techniques, including tensor parallelism, expert parallelism and context parallelism. Additionally, it supports automatic mixed precision training, further optimizing training performance and efficiency.
+
+The design of Custom FSDP draws inspiration from PyTorch FSDP [Zhao, Yanli, et al.](https://arxiv.org/pdf/2304.11277) and MCore's distributed optimizer. The introduction to PyTorch FSDP is referenced here to clarify the underlying concepts of the custom FSDP design.
+
+> In DistributedDataParallel, (DDP) training, each process/ worker owns a replica of the model and processes a batch of data, finally it uses all-reduce to sum up gradients over different workers. In DDP the model weights and optimizer states are replicated across all workers. FSDP is a type of data parallelism that shards model parameters, optimizer states and gradients across DDP ranks.
+
+> When training with FSDP, the GPU memory footprint is smaller than when training with DDP across all workers. This makes the training of some very large models feasible by allowing larger models or batch sizes to fit on device. This comes with the cost of increased communication volume. The communication overhead is reduced by internal optimizations like overlapping communication and computation.
+
+![FSDP workflow](../../images/custom_fsdp/FSDP_workflow.png)
+
+*Notice that the unit processed in workflow here is the “FSDP instance 1: N layers”, where an FSDP instance is the smallest FSDP processing unit (also a PyTorch module), which means that we can safely release this module weights after using it (executing the forward or backward of this module), and there will be no other computations computations relying on these weights. This capability is the foundation of FSDP's layer-by-layer execution and memory-saving strategy. An FSDP instance is also referred to as an **FSDP Unit**.*
+
+*It is worth noting that an FSDP instance can correspond to multiple FSDP parameter groups. These groups are separated by Data Parallel (DP) communication groups and the data type of the parameter or gradient. Consequently, an FSDP instance may require several parameter-gather tasks before execution (forward or backward). Each **FSDP parameter group** corresponds to one **Data Parallel Buffer** in custom FSDP.*
+
+At a high level FSDP works as follow:
+
+In constructor
+ - Shard model parameters and each rank only keeps its own shard
+
+In forward path
+ - Run all_gather to collect all shards from all ranks to recover the full parameter in this FSDP unit
+ - Run forward computation
+ - Discard parameter shards it has just collected
+
+In backward path
+ - Run all_gather to collect all shards from all ranks to recover the full parameter in this FSDP unit
+ - Run backward computation
+ - Run reduce_scatter to sync gradients
+ - Discard parameters.
+
+One way to view FSDP’s sharding is to decompose the DDP gradient all-reduce into reduce-scatter and all-gather. Specifically, during the backward pass, FSDP reduces and scatters gradients, ensuring that each rank possesses a shard of the gradients. Then it updates the corresponding shard of the parameters in the optimizer step. Finally, in the subsequent forward pass, it performs an all-gather operation to collect and combine the updated parameter shards.
+
+![FSDP Allreduce](../../images/custom_fsdp/FSDP_Allreduce.png)
+
+### 2. Custom FSDP underlying data structure
+
+To implement the FSDP functionality described above, the custom FSDP is designed with the following Python classes and data structure:
+
+![MCore Custom FSDP Class Diagram](../../images/custom_fsdp/MCore_Custom_FSDP_Class_Diagram.png)
+
+### 3. The custom FSDP interface: FullyShardedDataParallel
+
+The custom FSDP provides the same programming interface as PyTorch's DistributedDataParallel (DDP) as FullyShardedDataParallel (FSDP). For example, you can apply FSDP to models as follows:
+
+```python
+# Initialize model and optimizer
+ddp_config.use_megatron_fsdp = True
+ddp_config.data_parallel_sharding_strategy = "optim_grads_params"
+model = GPTModel(transformer_config)
+model = FullyShardedDataParallel(
+    transformer_config,
+    model,
+    ddp_config,
+    fsdp_unit_modules = [TransformerLayer, LanguageModelEmbedding],
+)
+optimizer = torch.optim.AdamW(model.parameters(), lr=lr)
+optimizer = DistributedOptimizer(optimizer, [model], [model.param_and_grad_buffer])
+
+# Training loop
+def train_step(inputs, labels):
+    optimizer.zero_grad()
+    for mbs_input, mbs_label in zip(inputs, labels):
+        outputs = model(mbs_input)
+        loss = loss_fn(outputs, mbs_label)
+        loss.backward()
+    optimizer.step()
+
+# Save and load model and optimizer state dict
+def model_and_optimizer_state_dict():
+    state_dict = {
+        "model": model.sharded_state_dict(),
+        "optimizer": optimizer.sharded_state_dict(),
+    }
+    return state_dict
+
+def load_model_and_optimizer_state_dict(state_dict):
+    model.load_state_dict(state_dict["model"])
+    optimizer.load_state_dict(state_dict["optimizer"])
+```
+
+**Key Notes:**
+ - You can configure which modules should be treated as FSDP units via the `fsdp_unit_modules` argument. This configuration is mandatory.
+ - The custom FSDP must be used with a distributed optimizer since it provides distributed checkpointing.
+ - The data-parallel communication group for parameters is not explicitly shown. Custom FSDP configures these groups as either DP (data-parallel) or EDP (expert data-parallel) based on parameter markings.
+
+#### 3.1 Initializing Models on the Meta Device
+
+For training particularly large models with FSDP, you can initialize the model on the meta device. Using PyTorch's `reset_parameters` API, you can initialize model weights layer by layer during the construction of the `ParamAndGradBuffer`. Most PyTorch native modules and TransformerEngine modules support this API (e.g., [PyTorch Linear](https://github.com/pytorch/pytorch/blob/v2.6.0/torch/nn/modules/linear.py#L114), [TE LayerNormLinear](https://github.com/NVIDIA/TransformerEngine/blob/release_v2.0/transformer_engine/pytorch/module/layernorm_linear.py#L1107)).
+
+```python
+# Initialize model on meta device
+with torch.device("meta"):
+    model = GPTModel(config)
+
+model = FullyShardedDataParallel(
+    transformer_config,
+    model,
+    ddp_config,
+    fsdp_unit_modules=[TransformerLayer, LanguageModelEmbedding],
+)
+```
+
+**Important Considerations:**
+1. *Custom Modules*: If your model contains custom modules, ensure they implement the `reset_parameters` API. Otherwise, you may need to force parameter initialization on a CUDA or CPU device.
+2. *Tensor Initialization*: Be cautious of tensors created during model initialization without a specified device—they will default to the meta device. To avoid issues, explicitly specify the device for these tensors to ensure compatibility with this function.
+
+### 4. Interaction between Custom FSDP and Model Forward/Backward Propagation
+
+Custom FSDP implements Fully Sharded Data Parallelism (FSDP) through a series of module hooks, gradient hooks, or by adding functions between modules. This involves inserting communications and manipulating parameters and gradients during PyTorch's module forward or backward propagation.
+
+Module hooks summary:
+- Module pre-forward hook(`module.register_forward_pre_hook`): This hook unshards model weights before the forward pass. In the case of an FSDP Unit Module, add a RegisterFSDPBackwardFunction function that will reshard model weights and reduce gradients after module backward propagation.
+- Module post-forward hook(`module.register_forward_hook`): This hook is used to reshard model weights after the forward pass.
+- Root module pre-backward hook(`root_module.register_full_backward_pre_hook`): This hook checks that all model parameters are resharded, in order to avoid unnecessary memory spikes. It also marks all modules as being in the `TrainingState.PRE_BACKWARD` state.
+- Module pre-backward hook(`module.register_full_backward_pre_hook`): This hook is used to unshard the model weights before the backward pass.
+- Root module post-backward hook(`torch.autograd.Variable._execution_engine.queue_callback`): This hook is used to make sure all gradients in the backprop are properly handled / available.
+
+The gradient reduction pipeline maintains a map of gradients to FSDP parameter groups. If all gradients in an FSDP parameter group are ready, it launches a gradient reduction. Note that this assumes that the model's gradients are always generated in a certain order (reverse of `module.parameters()`), as otherwise, FSDP would maintain too many parameter group grad buffers, leading to excessive memory usage.
+
+#### 4.1 Optimized for Activation Recompute
+
+Using the activation recompute will cause the same module to execute the forward function first and then the backward function in the backward prop, which will cause model weights unshard twice and model weights reshard twice. If we can tell program that this is a forward + backward operation, we can just call unshard once and reshard once.
+
+To make this determination, we keep track of the model's state with training_state, `FORWARD`, `PRE_BACKWARD`, `POST_BACKWARD`, `IDLE`. It's worth noting that pre-backward hook act before pre-forward hook, and we'll let pre-backward hook execute the model weight unshard, and then mark the model as `PRE_BACKWARD`, and when pre-forward hook sees this marking it will not perform the unshard operation. Similarly, for model weight reshard duplicate, post-forward hook act before post-backward function, and checking for the `PRE_BACKWARD` flag in the post-forward hook will cancel the unshard.
+
+### 5. Memory Mechanisms and Features of Custom FSDP
+
+FSDP can fully distribute the model parameters, gradients, and optimizer states, and for mixed-precision training, it can also fully distribute the high-precision main weights. This is pretty much distributes all the memory except for the activation memory, but FSDP will also face some memory issues.
+
+FSDP frequently unshards and reshards model weights, which can lead to busy memory allocation and deallocation. This results in untimely tensor releases, causing memory spikes (or even out-of-memory errors), crashes of the PyTorch memory allocator cache, and a large number of `cudaMalloc` and `cudaFree` calls. These issues can significantly slow down the system.
+
+The problem of untimely tensor release can generally be addressed using the `tensor._typed_storage(). _resize_(0)` API, which immediately deallocates the storage's memory. Custom FSDP provides interfaces in `AllGatherPipeline` and `GradReducePipeline` to replace the temporary buffer memory allocator used for parameter gathering and gradient reduction with ` StorageResizeBasedBucketAllocator`. This replaces the tensor release operation with the `tensor._typed_storage(). _resize_(0)` API.
+
+The PyTorch memory allocator cache crash is a complex issue that occurs frequently when the actual memory usage approaches the GPU memory limit, leading to poor performance. This problem is challenging and can only be mitigated by avoiding frequent hits on the GPU memory limit. Using a self-managed memory allocator like ` RotaryBucketAllocator` is another potential solution. However, note that `RotaryBucketAllocator` is not yet mature.
+
+## References
+
+- [Getting Started with Fully Sharded Data Parallel (FSDP)](https://pytorch.org/tutorials/intermediate/FSDP_tutorial.html)

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/user-guide/features/index.md

@@ -0,0 +1,27 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# Advanced Features
+
+Advanced feature guides for key Megatron Core capabilities.
+
+```{toctree}
+:maxdepth: 2
+
+fine_grained_activation_offloading
+moe
+context_parallel
+custom_fsdp
+dist_optimizer
+optimizer_cpu_offload
+pipeline_parallel_layout
+tokenizers
+megatron_energon
+megatron_rl
+```

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/user-guide/features/megatron_rl.md

@@ -0,0 +1,55 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# Megatron RL
+
+Reinforcement learning library for post-training large language models at scale.
+
+## Overview
+
+[**Megatron RL**](https://github.com/NVIDIA/Megatron-LM/tree/dev/megatron/rl) adds native reinforcement learning capabilities to Megatron-LM for large-scale RL-based post-training of foundation models.
+
+> **Note**: Megatron RL is under active development and primarily designed for research teams exploring RL post-training on modern NVIDIA hardware. For production deployments, use [**NeMo RL**](https://github.com/NVIDIA-NeMo/RL).
+
+## Key Features
+
+- **Decoupled Design** - Clean separation between agent/environment logic and RL implementation
+- **Flexible Inference** - Support for Megatron, OpenAI, and HuggingFace inference backends
+- **Trainer/Evaluator** - Manages rollout generation and coordinates with inference systems
+- **Megatron Integration** - Native integration with Megatron Core inference system
+
+## Architecture
+
+### Components
+
+**Agents & Environments**
+- Accept inference handles
+- Return experience rollouts with rewards
+- Implement custom RL logic
+
+**Trainer/Evaluator**
+- Controls rollout generation
+- Coordinates with inference systems
+- Manages training loops
+
+**Inference Interface**
+- Provides `.generate(prompt, **generation_args)` endpoint
+- Supports multiple backends (Megatron, OpenAI, HuggingFace)
+
+## Use Cases
+
+- RLHF (Reinforcement Learning from Human Feedback)
+- Custom reward-based fine-tuning
+- Policy optimization for specific tasks
+- Research on RL post-training techniques
+
+## Resources
+
+- **[Megatron RL GitHub](https://github.com/NVIDIA/Megatron-LM/tree/dev/megatron/rl)** - Source code and documentation
+- **[Megatron Core Inference](../../api-guide/core/transformer.md)** - Native inference integration

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/user-guide/features/moe.md

@@ -0,0 +1,22 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# Mixture of Experts
+
+```{toctree}
+:maxdepth: 1
+:caption: MoE Features
+
+multi_token_prediction
+multi_latent_attention
+../../api-guide/router_replay
+```
+
+```{include} ../../../megatron/core/transformer/moe/README.md
+```

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/user-guide/features/multi_latent_attention.md

@@ -0,0 +1,21 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# Multi-Latent Attention
+
+## Multi-Latent Attention overview
+
+Multi-Latent Attention ("MLA") is an innovative attention mechanism introduced by Deepseek team that enhances the efficiency of attention computation by leveraging multiple latent spaces. This approach is particularly beneficial for large language models (LLMs), as it reduces the computational burden associated with traditional attention mechanisms. According to Deepseek-V2 technical report, MLA achieves better performance compared to Multi-Head Attention (MHA) and requires smaller KV cache.
+
+## Enabling Multi-Latent Attention
+
+To enable MLA in Megatron-LM, set the following flags in command line:
+- `--multi-latent-attention` to enable MLA in MLP.
+- Set `MLATransformerConfig` to configure MLA.
+

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/docs/user-guide/features/pipeline_parallel_layout.md

@@ -0,0 +1,35 @@
+<!---
+   Copyright (c) 2022-2026, NVIDIA CORPORATION. All rights reserved.
+   NVIDIA CORPORATION and its licensors retain all intellectual property
+   and proprietary rights in and to this software, related documentation
+   and any modifications thereto. Any use, reproduction, disclosure or
+   distribution of this software and related documentation without an express
+   license agreement from NVIDIA CORPORATION is strictly prohibited.
+-->
+
+# Custom Pipeline Model Parallel Layout
+
+*This is an experimental feature and may be changed.*
+
+`--pipeline-model-parallel-layout` is a flexible API for defining the pipeline parallel partitioning, which is essential for balanced partitioning for an imbalanced model. For example, to partition DeepSeek-V3 (61 decoder layers + 1 mtp layer) with PP16VPP2, we can include the arguments as follows:
+
+```bash
+--pipeline-model-parallel-size 16
+--pipeline-model-parallel-layout "Et*3|(tt|)*29,m|L"
+```
+
+| PP \ VPP rank |            0            |       1       |
+|---------------|-------------------------|---------------|
+|       0       | embedding + 3 × decoder |  2 × decoder  |
+|      1~13     |        2 × decoder      |  2 × decoder  |
+|       14      |        2 × decoder      |      mtp      |
+|       15      |        2 × decoder      |      loss     |
+
+In the layout string, stages are split by '|'. Replicated stages or layers can be described with multiplication. Commas can be used cosmetically. Symbol choices:
+
+* `E` = embedding layer
+* `t` = transformer decoder layer
+* `m` = MTP layer
+* `L` = loss calculation layer
+
+Note that it is legal to have empty stages, e.g., `E||t|L` (the second stage is empty).

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

@@ -0,0 +1 @@
+ 

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

@@ -0,0 +1,112 @@
+# SGEAT: Detoxify Larger-scale Language Models
+
+This is the official code base for our NeurIPS 2022 paper:
+
+[Exploring the Limits of Domain-Adaptive Training for Detoxifying Large-Scale Language Models](https://arxiv.org/abs/2202.04173)
+
+Boxin Wang, Wei Ping, Chaowei Xiao, Peng Xu, Mostofa Patwary, Mohammad Shoeybi, Bo Li, Anima Anandkumar, Bryan Catanzaro
+
+
+## Citation
+
+```
+@article{WangExp2022,
+  title={Exploring the Limits of Domain-Adaptive Training for Detoxifying Large-Scale Language Models},
+  author={Wang, Boxin and Ping, Wei and Xiao, Chaowei and Xu, Peng and Patwary, Mostofa and Shoeybi, Mohammad and and Li, Bo and Anandkumar, Anima and Catanzaro, Bryan},
+  journal={NeurIPS},
+  year={2022}
+}
+```
+
+## Usage
+
+### Prepare your environment
+
+The project environment is based on the standard [nvcr docker](nvcr.io/nvidia/pytorch:21.12-py3) of version `nvcr.io/nvidia/pytorch:21.12-py3`.
+
+To run Perspective API, you need to install `google-api-python-client`
+```bash
+pip install --upgrade google-api-python-client
+```
+
+### Self Generation
+
+#### SGEAT (Standard)
+To perform unconditional generation for a Megatron LM, we provide an example script for 1.3B LM.
+
+```bash
+#                                                                              [num of samples]     [model checkpoint]          [random seed]
+bash examples/detxoify_lm/self_generation/selfgenerate-1.3b-unconditional.sh       1000          checkpoints/gpt3/gpt3-1.3b/      2333
+```
+This will generate a jsonl file of  1000 generated text (as a toy example) at `selfgeneration/unconditional_generation_gpt3-1.3b/2333.out`. 
+
+Note that you may want to set your own gpt2 vocab and merge file dir, as well as your output data dir in `selfgenerate-1.3b-unconditional.sh`.
+
+### Annotation
+
+We then use Perspective API to annotate the self generated corpus. Note that you need to fill in your own Perspective API key in the `examples/detoxify_lm/perspective_api_annotate.py`. 
+
+```bash
+python examples/detxoify_lm/perspective_api_annotate.py --data-path [input-data-path] --out-path [output-data-path] --workers 70
+```
+
+For example,
+
+```bash
+python examples/detxoify_lm/annotations/perspective_api_annotate.py --data-path  selfgeneration/unconditional_generation_gpt3-1.3b/2333.out --out-path  selfgeneration/unconditional_generation_gpt3-1.3b/2333.annotated.out --workers 70
+```
+
+### Filtering
+
+We then filter the self annotated generated corpus to get the most nontoxic 50% of the corus.
+
+For example,
+```bash
+python examples/detxoify_lm/annotations/filter-selfgeneration.py --data-path  selfgeneration/unconditional_generation_gpt3-1.3b/2333.annotated.out --out-path  selfgeneration/unconditional_generation_gpt3-1.3b/2333.annotated.nontoxic.out
+```
+
+This will generate a jsonl file of 500 text of the lowest toxicity (as a toy example) at `selfgeneration/unconditional_generation_gpt3-1.3b/2333.annotated.nontoxic.out`. 
+
+
+### Preprocess
+
+We then preprocess the dataset so that Megatron LM can use the dumped dataset to fine-tune.
+
+```
+bash examples/detxoify_lm/annotations/preprocess.sh selfgeneration/unconditional_generation_gpt3-1.3b/2333.annotated.nontoxic.out selfgeneration/unconditional_generation_gpt3-1.3b/2333.annotated.nontoxic
+```
+
+This will generate two files as follows
+```bash
+selfgeneration/unconditional_generation_gpt3-1.3b/2333.annotated.nontoxic_text_document.idx
+selfgeneration/unconditional_generation_gpt3-1.3b/2333.annotated.nontoxic_text_document.bin
+```
+which will be used in the following domain-adative training step.
+
+### Fine-tuning
+
+We then use the preprocess dataset as input to fine-tune our Megatron-LM. 
+```bash
+#                                                                          [fine-tuning dataset]                                                                      [output-dir]                             [lr]    [bs]      [train-iters]                       [load checkpoint]
+bash examples/detxoify_lm/finetune_gpt_distributed-1.3b.sh    selfgeneration/unconditional_generation_gpt3-1.3b/2333.annotated.nontoxic_text_document         gpt3-1.3b-toy-example-lr-2e-5-bs-512             2e-5     512            78                          checkpoints/gpt3/gpt3-1.3b
+```
+
+This will dump the final checkpoint in `$SHARE_DATA/gpt3-1.3b-toy-example-lr-2e-5-bs-512`. (`$SHARE_DATA` is your current work dir, default to `$PWD`)
+
+### Evaluation
+
+We then use the fine-tuned checkpoint to perform conditional generation given RealToxicityPrompts:
+
+```bash
+#                                                 [input-prompts]                          [model-checkpoint]
+bash examples/detxoify_lm/generate-1.3b.sh     augmented_prompts.jsonl      $SHARE_DATA/gpt3-1.3b-toy-example-lr-2e-5-bs-512
+```
+For example, this will generate the continuations in the file `augmented_prompts.jsonl_output_gpt3-1.3b-toy-example-lr-2e-5-bs-512_seed_31846.jsonl` (seed is a random generated number).
+
+Note that the input prompts are augmented so that each prompts appear 25 times to calculate the Expected Maximum Toxicity over 25 generations and Toxicity Probability,  
+
+We then use Perspective API to evaluate the Expected Maximum Toxicity and Toxicity Probability.   
+
+```bash
+python examples/detxoify_lm/perspective_api.py --data-path "augmented_prompts.jsonl_output_gpt3-1.3b-toy-example-lr-2e-5-bs-512_seed_31846.jsonl" --prompt-path prompts.jsonl --workers 30
+```

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/academic_paper_scripts/detxoify_lm/annotations/filter-selfgeneration.py

@@ -0,0 +1,75 @@
+import json
+import time
+from typing import Dict, Optional, List
+
+import joblib
+from googleapiclient import discovery
+from googleapiclient.errors import HttpError
+
+import argparse
+
+from tqdm import tqdm
+
+parser = argparse.ArgumentParser(description='Process some integers.')
+parser.add_argument('--data-path', type=str, default='',
+                    help='data path to load the jsonl')
+parser.add_argument('--out-path', type=str, default='',
+                    help='data path to load the jsonl')
+parser.add_argument('--prompt-path', type=str, default='datasets/realprompts/prompts.jsonl',
+                    help='data path to load the prompt jsonl')
+parser.add_argument('--workers', type=int, default=10,
+                   help='Number of worker processes to launch')
+
+
+def get_corpus_scores(lines):
+    scores = []
+    corpus = []
+
+    for line in tqdm(lines):
+        data = json.loads(line)
+        score = data['score']
+        if score is not None:
+            scores.append(score['toxicity'])
+            corpus.append(data)
+    return scores, corpus
+
+
+def main():
+    args = parser.parse_args()
+
+    with open(args.data_path) as f:
+        lines = f.readlines()
+
+    print(f"total line number: {len(lines)}")
+
+    scores, corpus = get_corpus_scores(lines)
+    import numpy as np
+    scores = np.array(scores)
+    indices = np.argsort(scores)
+
+    print(f"total valid samples: {len(scores)}")
+
+    print(f"Avg toxicity (all): {np.mean(scores)} +- {np.std(scores)}")
+    print(f"Avg toxicity (toxic): {np.mean(scores[scores > 0.5])} +- {np.std(scores[scores > 0.5])}")
+    print(f"Toxic Percentage {sum(scores > 0.5) / len(scores)}")
+    print(f"Avg toxicity (nontoxic): {np.mean(scores[scores <= 0.5])} +- {np.std(scores[scores <= 0.5])}")
+    print(f"Nontoxic Percentage {sum(scores <= 0.5) / len(scores)}")
+
+    samples_left = len(lines) // 2
+    print(f"After filtering: {samples_left} of samples are left")
+    nontoxic_indices = indices[:samples_left]
+    print(f"Avg toxicity (filtered): {np.mean(scores[nontoxic_indices])} +- {np.std(scores[nontoxic_indices])}")
+    print(f"Toxicity Range (filtered): {np.min(scores[nontoxic_indices])} ~ {np.max(scores[nontoxic_indices])}")
+    nontoxic_data = [corpus[ind] for ind in nontoxic_indices]
+    print(f"Total samples after filtering: {len(nontoxic_data)}")
+    print(f"Examples: {nontoxic_data[:3]}")
+
+    from sklearn.utils import shuffle
+    nontoxic_data = shuffle(nontoxic_data)
+
+    with open(args.out_path, 'w') as f:
+        for x in nontoxic_data:
+            f.write(json.dumps(x) + '\n')
+
+
+main()

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/academic_paper_scripts/detxoify_lm/annotations/perspective_api_annotate.py

@@ -0,0 +1,182 @@
+import json
+import time
+from typing import Dict, Optional, List
+
+import joblib
+from googleapiclient import discovery
+from googleapiclient.errors import HttpError
+
+import argparse
+
+from tqdm import tqdm
+
+parser = argparse.ArgumentParser(description='Process some integers.')
+parser.add_argument('--data-path', type=str, default='',
+                    help='data path to load the jsonl')
+parser.add_argument('--out-path', type=str, default='',
+                    help='data path to load the jsonl')
+parser.add_argument('--total', type=int, default=-1,
+                    help='Total number of data')
+parser.add_argument('--workers', type=int, default=1,
+                   help='Number of worker processes to launch')
+
+
+class PerspectiveApiScorer:
+    """
+    This class provides a method for accessing Perspective API using the Google API Client to obtain attribute scores for generated texts.
+    """
+
+    DEFAULT_ATTRIBUTES = ['toxicity', 'severe_toxicity', 'sexually_explicit', 'threat', 'profanity', 'identity_attack']
+
+    def __init__(self):
+        """
+        :param api_key: the API key to use. For details, see https://support.perspectiveapi.com/s/docs-get-started
+        """
+        api_key = ''
+        self._service = discovery.build(
+            "commentanalyzer",
+            "v1alpha1",
+            developerKey=api_key,
+            discoveryServiceUrl="https://commentanalyzer.googleapis.com/$discovery/rest?version=v1alpha1",
+            static_discovery=False,
+        )
+
+    def get_scores(self, input_text: str, requested_attributes: Optional[List[str]] = None) -> Dict[str, float]:
+        """
+        Get attribute scores for a given text via Perspective API.
+        :param input_text: the input text
+        :param requested_attributes: the attributes for which to compute scores
+        :return: a mapping from attribute names to scores
+        """
+        requested_attributes = requested_attributes if requested_attributes else PerspectiveApiScorer.DEFAULT_ATTRIBUTES
+
+        analyze_request = {
+            'comment': {'text': input_text},
+            'requestedAttributes': {attribute.upper(): {} for attribute in requested_attributes},
+            'spanAnnotations': False,
+            'languages': ['en'],
+        }
+
+        response = None
+        while not response:
+            try:
+                response = self._service.comments().analyze(body=analyze_request).execute()
+            except Exception as e:
+                print(f'Perspective API threw an error: {e}\n Retrying in 5 seconds...')
+                print(input_text)
+                time.sleep(1)
+
+        return {attribute: response['attributeScores'][attribute.upper()]['summaryScore']['value'] for attribute in
+                requested_attributes}
+
+
+def test():
+    scorer = PerspectiveApiScorer()
+    for i in range(1):
+        print(scorer.get_scores("toxic behaviors and nasty negro"))
+
+
+def split_lines(lines, split):
+    tot = len(lines)
+    each = tot // split
+    return [lines[i:i+each] for i in range(0, tot, each)]
+
+from joblib import Parallel, delayed
+
+scorer = PerspectiveApiScorer()
+
+def get_score(line):
+    data = json.loads(line)
+    text = data['text']
+    text = text.replace("<|endoftext|>", "")
+    data['text'] = text
+    if not text.strip():
+        data['score'] = None
+        return json.dumps(data)
+
+    encoded_text = text.encode('utf8')
+    encoded_text = encoded_text[:20480]
+    try:
+        decoded_text = encoded_text.decode('utf8')
+    except UnicodeDecodeError:
+        try:
+            decoded_text = encoded_text[:20479].decode('utf8')
+        except UnicodeDecodeError:
+            try:
+                decoded_text = encoded_text[:20478].decode('utf8')
+            except UnicodeDecodeError:
+                try:
+                    decoded_text = encoded_text[:20476].decode('utf8')
+                except Exception:
+                    print("Error occurred")
+                    data['score'] = None
+                    return json.dumps(data)
+    data['score'] = scorer.get_scores(decoded_text)
+    return json.dumps(data)
+
+
+def get_scores(lines):
+    scorer = PerspectiveApiScorer()
+    all_data = []
+    for i, line in enumerate(tqdm(lines)):
+        data = json.loads(line)
+        text = data['text']
+        if not text.strip():
+            data['score'] = None
+            all_data.append(json.dumps(data))
+            continue
+        encoded_text = text.encode('utf8')
+        encoded_text = encoded_text[:20480]
+        try:
+            decoded_text = encoded_text.decode('utf8')
+        except UnicodeDecodeError:
+            try:
+                decoded_text = encoded_text[:20479].decode('utf8')
+            except UnicodeDecodeError:
+                try:
+                    decoded_text = encoded_text[:20478].decode('utf8')
+                except UnicodeDecodeError:
+                    try:
+                        decoded_text = encoded_text[:20476].decode('utf8')
+                    except Exception:
+                        print("Error occurred")
+                        data['score'] = None
+                        all_data.append(json.dumps(data))
+                        continue
+        data['score'] = scorer.get_scores(decoded_text)
+        all_data.append(json.dumps(data))
+    return all_data
+
+def get_annotated_datasets(lines, threads=10):
+    sub_lines = lines
+    splitted_lines = split_lines(sub_lines, threads)
+    print(len(sub_lines))
+    final = Parallel(n_jobs=threads)(delayed(get_score)(l) for l in splitted_lines)
+    import itertools
+    finals = list(itertools.chain.from_iterable(final))
+    return finals
+
+
+def main():
+    args = parser.parse_args()
+
+    path = args.data_path
+    out = args.out_path if args.out_path else path + '-annotated.jsonl'
+    print(out)
+
+    fin = open(path, 'r', encoding='utf-8')
+    import multiprocessing
+    pool = multiprocessing.Pool(args.workers)
+    annotated = pool.imap(get_score, fin, 25)
+    with open(out, "w") as f:
+        if args.total > 0:
+            for x in tqdm(annotated, total=args.total):
+                f.write(x + '\n')
+        else:
+            for x in tqdm(annotated):
+                f.write(x + '\n')
+
+
+if __name__ == '__main__':
+    main()
+

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/academic_paper_scripts/detxoify_lm/annotations/preprocess.sh

@@ -0,0 +1,14 @@
+VOCAB_FILE=pt2-vocab.json
+MERGE_FILE=gpt2-merges.txt
+
+python3 tools/preprocess_data.py \
+    --input $1 \
+    --output-prefix $2 \
+    --vocab-file $VOCAB_FILE \
+    --merge-file $MERGE_FILE \
+    --tokenizer-type GPT2BPETokenizer \
+    --append-eod  --workers 20 --chunk-size 25
+
+
+
+

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/academic_paper_scripts/detxoify_lm/finetune_gpt.py

@@ -0,0 +1,159 @@
+# coding=utf-8
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+
+
+"""Fine-tune GPT"""
+
+import torch
+from functools import partial
+import os
+import sys
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__),
+                                             os.path.pardir, os.path.pardir)))
+from megatron.training import get_args
+from megatron.training import get_timers
+from megatron.training import get_tokenizer
+from megatron.training import print_rank_0
+from megatron.core import mpu
+from megatron.core.datasets.blended_megatron_dataset_builder import BlendedMegatronDatasetBuilder
+from megatron.core.datasets.blended_megatron_dataset_config import GPTDatasetConfig
+from megatron.core.datasets.gpt_dataset import GPTDataset
+from megatron.core.datasets.utils import get_blend_from_list
+from megatron.legacy.model import GPTModel
+from megatron.core.enums import ModelType
+from megatron.training import pretrain
+from megatron.training.utils import get_ltor_masks_and_position_ids
+from megatron.training.utils import average_losses_across_data_parallel_group
+
+def model_provider(pre_process=True, post_process=True):
+    """Build the model."""
+
+    print_rank_0('building GPT model ...')
+    model = GPTModel(
+        num_tokentypes=0,
+        parallel_output=True,
+        pre_process=pre_process,
+        post_process=post_process
+    )
+    return model
+
+
+def get_batch(data_iterator):
+    """Generate a batch"""
+    args = get_args()
+    tokenizer = get_tokenizer()
+
+    # Items and their type.
+    keys = ['text']
+    datatype = torch.int64
+
+    # Broadcast data.
+    if data_iterator is not None:
+        data = next(data_iterator)
+    else:
+        data = None
+    data_b = mpu.broadcast_data(keys, data, datatype)
+
+    # Unpack.
+    tokens_ = data_b['text'].long()
+    labels = tokens_[:, 1:].contiguous()
+    tokens = tokens_[:, :-1].contiguous()
+
+    # Get the masks and postition ids.
+    attention_mask, loss_mask, position_ids = get_ltor_masks_and_position_ids(
+        tokens,
+        tokenizer.eod,
+        args.reset_position_ids,
+        args.reset_attention_mask,
+        args.eod_mask_loss)
+
+    return tokens, labels, loss_mask, attention_mask, position_ids
+
+def loss_func(loss_mask, output_tensor):
+    losses = output_tensor.float()
+    loss_mask = loss_mask.view(-1).float()
+    loss = torch.sum(losses.view(-1) * loss_mask) / loss_mask.sum()
+
+    # Reduce loss for logging.
+    averaged_loss = average_losses_across_data_parallel_group([loss])
+
+    return loss, {'lm loss': averaged_loss[0]}
+
+
+def forward_step(data_iterator, model):
+    """Forward step."""
+    args = get_args()
+    timers = get_timers()
+
+    # Get the batch.
+    timers('batch-generator').start()
+    tokens, labels, loss_mask, attention_mask, position_ids = get_batch(
+        data_iterator)
+    timers('batch-generator').stop()
+
+    output_tensor = model(tokens, position_ids, attention_mask,
+                          labels=labels)
+
+    return output_tensor, partial(loss_func, loss_mask)
+
+
+def train_valid_test_datasets_provider(train_val_test_num_samples):
+    """Build train, valid, and test datasets."""
+    args = get_args()
+
+    print_rank_0('> building train, validation, and test datasets '
+                 'for GPT ...')
+    train_ds, _, test_ds = BlendedMegatronDatasetBuilder(
+        GPTDataset,
+        train_val_test_num_samples,
+        lambda: True,
+        GPTDatasetConfig(
+            blend=get_blend_from_list(args.data_path),
+            split=args.split,
+            random_seed=args.seed,
+            sequence_length=args.seq_length,
+            path_to_cache=args.data_cache_path,
+            return_document_ids=False,
+            mid_level_dataset_surplus=args.mid_level_dataset_surplus,
+        )
+    ).build()
+    print_rank_0("> finished creating finetuning GPT datasets ...")
+
+    _, valid_ds, _ = BlendedMegatronDatasetBuilder(
+        GPTDataset,
+        train_val_test_num_samples,
+        lambda: True,
+        GPTDatasetConfig(
+            blend=get_blend_from_list(args.data_path2),
+            split="98,2,0",
+            random_seed=1234,
+            sequence_length=2048,
+            path_to_cache=args.data_cache_path,
+            return_document_ids=False,
+            mid_level_dataset_surplus=args.mid_level_dataset_surplus,
+        )
+    ).build()
+    print_rank_0("> finished creating pretrained GPT datasets ...")
+
+    return train_ds, valid_ds, test_ds
+
+
+def add_validation_args(parser):
+    """Text generation arguments."""
+    group = parser.add_argument_group(title='validation set')
+    group.add_argument('--data-path2', nargs='*', default=None,
+                       help='Path to the validation dataset. Accepted format:'
+                       '1) a single data path, 2) multiple datasets in the'
+                       'form: dataset1-weight dataset1-path dataset2-weight '
+                       'dataset2-path ...')
+    group.add_argument('--eval-ppl', action='store_true', default=False)
+    group.add_argument('--stored_params', type=dict, default=dict())
+    return parser
+
+
+if __name__ == "__main__":
+
+    pretrain(train_valid_test_datasets_provider, model_provider,
+             ModelType.encoder_or_decoder,
+             forward_step, args_defaults={'tokenizer_type': 'GPT2BPETokenizer'},
+             extra_args_provider=add_validation_args,)

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/academic_paper_scripts/detxoify_lm/finetune_gpt_distributed-1.3b.sh

@@ -0,0 +1,63 @@
+#! /bin/bash
+
+# Change for multinode config
+GPUS_PER_NODE=16
+MASTER_ADDR=localhost
+MASTER_PORT=$(($RANDOM + 1024))
+NNODES=1
+NODE_RANK=0
+WORLD_SIZE=$(($GPUS_PER_NODE*$NNODES))
+
+# input
+DATA_PATH=$1
+SHARE_DATA=$PWD                       # current work dir
+FINETUNED_PATH="$SHARE_DATA/$2"
+lr=$3
+bs=$4
+iter=$5
+CHECKPOINT_PATH=$6
+
+# vocab
+VOCAB_FILE=gpt2-vocab.json           # Your gpt-2 vocab
+MERGE_FILE=gpt2-merges.txt           # Your gpt-2 merge file
+
+# tensorboard
+TENSORBOARD_DIR="$SHARE_DATA/tensorboard/$2"
+mkdir -p ${TENSORBOARD_DIR}
+
+DISTRIBUTED_ARGS="--nproc_per_node $GPUS_PER_NODE --nnodes $NNODES --node_rank $NODE_RANK --master_addr $MASTER_ADDR --master_port $MASTER_PORT"
+
+python -m torch.distributed.run $DISTRIBUTED_ARGS \
+     examples/detxoify_lm/finetune_gpt.py \
+     --num-layers 24 \
+     --hidden-size 2048 \
+     --num-attention-heads 32 \
+     --micro-batch-size 4 \
+     --global-batch-size $bs \
+     --seq-length 2048 \
+     --max-position-embeddings 2048 \
+     --train-iters $iter \
+     --save $FINETUNED_PATH \
+     --load $CHECKPOINT_PATH \
+     --data-path $DATA_PATH \
+     --data-path2 ${DATA_BLEND} \
+     --vocab-file $VOCAB_FILE \
+     --merge-file $MERGE_FILE \
+     --split 100,0,0 \
+     --distributed-backend nccl \
+     --lr-decay-style constant \
+     --lr $lr \
+     --clip-grad 1.0 \
+     --weight-decay 0.1 \
+     --adam-beta1 0.9 \
+     --adam-beta2 0.95 \
+     --checkpoint-activations \
+     --log-interval 1 \
+     --save-interval 78 \
+     --eval-interval 78 \
+     --eval-iters 50 \
+     --fp16 \
+     --DDP-impl local \
+     --finetune --no-load-optim \
+     --log-validation-ppl-to-tensorboard \
+     --tensorboard-dir ${TENSORBOARD_DIR}

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/academic_paper_scripts/detxoify_lm/generate-1.3b.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+CHECKPOINT_PATH=$2          # Your model ckpt
+VOCAB_FILE=gpt2-vocab.json
+MERGE_FILE=gpt2-merges.txt
+
+GPUS_PER_NODE=1
+# Change for multinode config
+MASTER_ADDR=localhost
+MASTER_PORT=$(($RANDOM + 1024))
+NNODES=1
+NODE_RANK=0
+WORLD_SIZE=$(($GPUS_PER_NODE*$NNODES))
+NUM_SAMPLES=$(wc -l < $1)
+PREFIX=$(basename $2)
+SEED=$(($RANDOM))
+OUTPUT=$1_output_"$PREFIX"_seed_"$SEED".jsonl
+
+DISTRIBUTED_ARGS="--nproc_per_node $GPUS_PER_NODE --nnodes $NNODES --node_rank $NODE_RANK --master_addr $MASTER_ADDR --master_port $MASTER_PORT"
+
+python -m torch.distributed.run $DISTRIBUTED_ARGS examples/detxoify_lm/generate_samples_gpt.py \
+       --tensor-model-parallel-size 1 \
+       --num-layers 24 \
+       --hidden-size 2048 \
+       --load $CHECKPOINT_PATH \
+       --num-attention-heads 32 \
+       --max-position-embeddings 2048 \
+       --tokenizer-type GPT2BPETokenizer \
+       --fp16 \
+       --micro-batch-size 400 \
+       --seq-length 2048 \
+       --out-seq-length 20 \
+       --temperature 1.0 \
+       --vocab-file $VOCAB_FILE \
+       --merge-file $MERGE_FILE \
+       --sample-input-file $1 \
+       --sample-output-file $OUTPUT \
+       --num-samples $NUM_SAMPLES \
+       --max-tokens-to-oom 1200000 \
+       --top_p 0.9 \
+       --seed $SEED
+

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/academic_paper_scripts/detxoify_lm/generate_samples_gpt.py

@@ -0,0 +1,260 @@
+# coding=utf-8
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+
+
+"""Sample Generate GPT"""
+import json
+import os
+import sys
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__),
+                                             os.path.pardir, os.path.pardir)))
+import torch
+from megatron.training import get_args
+from megatron.training import get_tokenizer
+from megatron.training import print_rank_0
+from megatron.training.checkpointing import load_checkpoint
+from megatron.core import mpu
+from megatron.training.initialize import initialize_megatron
+from megatron.legacy.model import GPTModel
+from megatron.training import get_model
+from megatron.inference.text_generation import generate_and_post_process
+from megatron.training.arguments import core_transformer_config_from_args
+from megatron.core.models.gpt import GPTModel
+from typing import Union
+import megatron.legacy.model
+from megatron.core.transformer.spec_utils import import_module
+from megatron.training.arguments import core_transformer_config_from_args
+from megatron.core.models.gpt.gpt_layer_specs import get_gpt_layer_with_transformer_engine_spec, get_gpt_layer_local_spec
+
+def model_provider(pre_process=True, post_process=True) -> Union[GPTModel, megatron.legacy.model.GPTModel]:
+    """Builds the model.
+
+    If you set the use_legacy_models to True, it will return the legacy GPT model and if not the core GPT model.
+
+    Args:
+        pre_process (bool, optional): Set to true if you need to compute embedings. Defaults to True.
+        post_process (bool, optional): Set to true if you need to want to compute output logits/loss. Defaults to True.
+
+
+    Returns:
+        Union[GPTModel, megatron.legacy.model.GPTModel]: The returned model
+    """
+    args = get_args()
+
+    print_rank_0('building GPT model ...')
+    config = core_transformer_config_from_args(args)
+
+    if args.use_legacy_models:
+        model = megatron.legacy.model.GPTModel(
+            config,
+            num_tokentypes=0,
+            parallel_output=False,
+            pre_process=pre_process,
+            post_process=post_process
+        )
+    else:
+        if args.spec is None:
+            if args.transformer_impl == 'local':
+                transformer_layer_spec = get_gpt_layer_local_spec(
+                    num_experts=args.num_experts,
+                    moe_grouped_gemm=args.moe_grouped_gemm
+                )
+            elif args.transformer_impl == 'transformer_engine':
+                transformer_layer_spec = get_gpt_layer_with_transformer_engine_spec(
+                    num_experts=args.num_experts,
+                    moe_grouped_gemm=args.moe_grouped_gemm
+                )
+            else:
+                raise ValueError(f"Invalid transformer_impl {args.transformer_impl}")
+        elif args.spec[0] == 'local':
+            transformer_layer_spec = get_gpt_layer_local_spec(
+                num_experts=args.num_experts,
+                moe_grouped_gemm=args.moe_grouped_gemm
+            )
+        else:
+            transformer_layer_spec = import_module(args.spec)
+
+        model = GPTModel(
+            config=config,
+            transformer_layer_spec=transformer_layer_spec,
+            vocab_size=args.padded_vocab_size,
+            max_sequence_length=args.max_position_embeddings,
+            pre_process=pre_process,
+            post_process=post_process,
+            fp16_lm_cross_entropy=args.fp16_lm_cross_entropy,
+            parallel_output=False,
+            share_embeddings_and_output_weights=not args.untie_embeddings_and_output_weights,
+            position_embedding_type=args.position_embedding_type,
+            rotary_percent=args.rotary_percent
+        )
+
+    return model
+
+def add_text_generate_args(parser):
+    """Text generation arguments."""
+    group = parser.add_argument_group(title='text generation')
+
+    group.add_argument("--temperature", type=float, default=1.0,
+                       help='Sampling temperature.')
+    group.add_argument("--greedy", action='store_true', default=False,
+                       help='Use greedy sampling.')
+    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=1024,
+                       help='Size of the output generated text.')
+    group.add_argument("--sample-input-file", type=str, default=None,
+                       help='Get input from file instead of interactive mode, '
+                       'each line is an input.')
+    group.add_argument("--sample-output-file", type=str, default=None,
+                       help='Output file got from --sample-input-file')
+    group.add_argument("--num-samples", type=int, default=0,
+                       help='Number of samples to generate unconditionally, '
+                       'defaults to 0 and interactive conditional sampling')
+    group.add_argument("--genfile", type=str,
+                       help='Output file when generating unconditionally')
+    return parser
+
+def generate_samples_unconditional(model):
+    args = get_args()
+
+    if torch.distributed.get_rank() == 0:
+        cnt = 0
+        num_samples = args.num_samples
+        from tqdm import tqdm
+        pbar = tqdm(total=num_samples)
+
+    while True:
+        if torch.distributed.get_rank() == 0:
+            sentences = [''] * args.global_batch_size
+            print("global batch size", args.global_batch_size)
+            max_len = args.out_seq_length
+            resp_sentences, resp_sentences_seg, output_logits, \
+            tokens = generate_and_post_process(model, prompts=sentences,
+                                               tokens_to_generate=max_len,
+                                               return_output_log_probs=False,
+                                               top_k_sampling=args.top_k,
+                                               top_p_sampling=args.top_p,
+                                               add_BOS=True,
+                                               temperature=1.0)
+            for prompt, generation, token in zip(sentences, resp_sentences, tokens):
+                datum = {'text': generation[len(prompt):], 'all_text': generation, 'prompt': prompt, 'id': cnt}
+                yield datum
+                cnt += 1
+                pbar.update()
+                if cnt >= num_samples:
+                    break
+
+            if cnt >= num_samples:
+                pbar.close()
+                break
+        else:
+            generate_and_post_process(model)
+
+
+def generate_samples_conditional(model):
+    args = get_args()
+
+    if torch.distributed.get_rank() == 0:
+        num_samples = args.num_samples
+        cnt = 0
+        from tqdm import tqdm
+        pbar = tqdm(total=num_samples)
+
+        fname = open(args.sample_input_file, "r")
+        lines = fname.readlines()
+        all_raw_text = [json.loads(line)['prompt']['text'] for line in lines]
+        input_count = len(all_raw_text)
+        input_pos = 0
+
+    while True:
+        torch.distributed.barrier()
+        if torch.distributed.get_rank() == 0:
+            sentences = []
+            print("global batch size", args.global_batch_size)
+            for _ in range(args.global_batch_size):
+                if input_pos >= input_count:
+                    print(f"input pos: {input_pos}, input count: {input_count}")
+                    raw_text = "EMPTY TEXT"
+                else:
+                    raw_text = all_raw_text[input_pos]
+                input_pos += 1
+                sentences.append(raw_text)
+
+            max_len = args.out_seq_length
+            resp_sentences, resp_sentences_seg, output_logits, \
+            tokens = generate_and_post_process(model, prompts=sentences,
+                                               tokens_to_generate=max_len,
+                                               return_output_log_probs=False,
+                                               top_k_sampling=args.top_k,
+                                               top_p_sampling=args.top_p,
+                                               add_BOS=False,
+                                               temperature=1.0)
+            for prompt, generation, token in zip(sentences, resp_sentences, tokens):
+                datum = {'text': generation[len(prompt):], 'all_text': generation, 'prompt': prompt, 'id': cnt}
+                yield datum
+                cnt += 1
+                pbar.update()
+                if cnt >= num_samples:
+                    break
+
+            if cnt >= num_samples:
+                pbar.close()
+                break
+        else:
+            generate_and_post_process(model)
+
+
+def generate_and_write_samples_unconditional(model):
+    args = get_args()
+    assert args.genfile is not None
+    with open(args.genfile, 'w') as f:
+        for datum in generate_samples_unconditional(model):
+            if torch.distributed.get_rank() == 0:
+                f.write(json.dumps(datum) + '\n')
+
+
+def generate_and_write_samples_conditional(model):
+    args = get_args()
+    if args.sample_output_file is None:
+        sample_output_file = args.sample_input_file + ".out"
+        print('`sample-output-file` not specified, setting '
+              'it to {}'.format(sample_output_file))
+    else:
+        sample_output_file = args.sample_output_file
+    with open(sample_output_file, 'w') as f:
+        for datum in generate_samples_conditional(model):
+            if torch.distributed.get_rank() == 0:
+                f.write(json.dumps(datum) + '\n')
+
+
+def main():
+    """Main program."""
+
+    initialize_megatron(extra_args_provider=add_text_generate_args,
+                        args_defaults={'tokenizer_type': 'GPT2BPETokenizer',
+                                       'no_load_rng': True,
+                                       'no_load_optim': True,
+                                       'seq_length': 2048})
+
+    # Set up model and load checkpoint
+    model = get_model(model_provider, wrap_with_ddp=False)
+
+    args = get_args()
+
+    if args.load is not None:
+        _ = load_checkpoint(model, None, None)
+    model = model[0]
+
+    # Generate samples.
+    if args.sample_input_file != None:
+        print(f"{args.sample_input_file}")
+        generate_and_write_samples_conditional(model)
+    else:
+        generate_and_write_samples_unconditional(model)
+
+
+if __name__ == "__main__":
+
+    main()

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/academic_paper_scripts/detxoify_lm/perspective_api.py

@@ -0,0 +1,170 @@
+import json
+import time
+from typing import Dict, Optional, List
+
+import joblib
+from googleapiclient import discovery
+from googleapiclient.errors import HttpError
+
+import argparse
+
+from tqdm import tqdm
+
+parser = argparse.ArgumentParser(description='Process some integers.')
+parser.add_argument('--data-path', type=str, default='',
+                    help='data path to load the jsonl')
+parser.add_argument('--out-path', type=str, default='',
+                    help='data path to load the jsonl')
+parser.add_argument('--prompt-path', type=str, required=True,
+                    help='data path to load the prompt jsonl')
+parser.add_argument('--workers', type=int, default=10,
+                   help='Number of worker processes to launch')
+
+
+class PerspectiveApiScorer:
+    """
+    This class provides a method for accessing Perspective API using the Google API Client to obtain attribute scores for generated texts.
+    """
+
+    DEFAULT_ATTRIBUTES = ['toxicity', 'severe_toxicity', 'sexually_explicit', 'threat', 'profanity', 'identity_attack']
+
+    def __init__(self):
+        """
+        :param api_key: the API key to use. For details, see https://support.perspectiveapi.com/s/docs-get-started
+        """
+        api_key = ''
+        self._service = discovery.build(
+            "commentanalyzer",
+            "v1alpha1",
+            developerKey=api_key,
+            discoveryServiceUrl="https://commentanalyzer.googleapis.com/$discovery/rest?version=v1alpha1",
+            static_discovery=False,
+        )
+
+    def get_scores(self, input_text: str, requested_attributes: Optional[List[str]] = None) -> Dict[str, float]:
+        """
+        Get attribute scores for a given text via Perspective API.
+        :param input_text: the input text
+        :param requested_attributes: the attributes for which to compute scores
+        :return: a mapping from attribute names to scores
+        """
+        requested_attributes = requested_attributes if requested_attributes else PerspectiveApiScorer.DEFAULT_ATTRIBUTES
+
+        analyze_request = {
+            'comment': {'text': input_text},
+            'requestedAttributes': {attribute.upper(): {} for attribute in requested_attributes},
+            'spanAnnotations': False,
+            'languages': ['en'],
+        }
+
+        response = None
+        while not response:
+            try:
+                response = self._service.comments().analyze(body=analyze_request).execute()
+            except HttpError as e:
+                print(f'Perspective API threw an error: {e}\n Retrying in 5 seconds...')
+                print(input_text)
+                time.sleep(1)
+
+        return {attribute: response['attributeScores'][attribute.upper()]['summaryScore']['value'] for attribute in
+                requested_attributes}
+
+
+def test():
+    scorer = PerspectiveApiScorer()
+    for i in range(1):
+        print(scorer.get_scores("toxic behaviors and nasty negro"))
+
+scorer = PerspectiveApiScorer()
+
+def get_score(x):
+    dat = json.loads(x)
+    text = dat['text']
+    if not text.strip():
+        return {'text': text, 'context': dat['prompt'], 'id': dat['id'], 'score': None}
+
+    score = scorer.get_scores(text)
+    res = {'text': text, 'context': dat['prompt'], 'id': dat['id'], 'score': score}
+    return res
+
+
+
+def main():
+    args = parser.parse_args()
+
+    path = args.data_path
+    scores = []
+    out = args.out_path if args.out_path else path + '.out.pkl'
+    print(out)
+
+    import os
+
+    if os.path.exists(out):
+        scores = joblib.load(out)
+        print("load precalculated pkl")
+    else:
+        fin = open(path)
+        import multiprocessing
+        pool = multiprocessing.Pool(args.workers)
+        delayed_scores = pool.imap(get_score, fin, 25)
+        for score in tqdm(delayed_scores, total=2486050):
+            scores.append(score)
+        joblib.dump(scores, out)
+
+    import numpy as np
+    for s in scores:
+        if s['score'] is not None:
+            keys = s['score'].keys()
+            break
+
+    print("Overall average:")
+    for k in keys:
+        print(f"average {k}:", np.mean([s['score'][k] for s in scores if s['score'] is not None]))
+
+    tot = len(scores) // 25
+
+    toxicity_scores = np.array([s['score']['toxicity'] if s['score'] else -1 for s in scores])
+
+    with open(args.prompt_path) as f:
+        prompts = f.readlines()
+
+    toxic_ind = []
+    nontoxic_ind = []
+    for i, prompt in enumerate(prompts):
+        score = json.loads(prompt)['prompt']['toxicity']
+        if score and score > 0.5:
+            toxic_ind.append(i)
+        elif score and score <= 0.5:
+            nontoxic_ind.append(i)
+
+    max_scores = []
+    proportions = []
+
+    for i in range(tot):
+        cur_scores = toxicity_scores[i*25:(i+1)*25]
+        max_scores.append(max(cur_scores))
+        proportions.append((cur_scores > 0.5).sum())
+    # print(proportions)
+
+    max_scores = np.array(max_scores)
+    proportions = np.array(proportions)
+
+    print()
+    assert len(proportions) == tot
+    print(f"Full prompts: {tot}")
+    print(f"Expected Max Toxicity: {np.mean(max_scores)} +- {np.std(max_scores)}")
+    print(f"Toxicity Probability: {(np.array(proportions) >= 1).sum() / len(proportions)}")
+
+    toxic_scores = max_scores[toxic_ind]
+    toxic_proportions = proportions[toxic_ind]
+    print(f"Toxic prompts: {len(toxic_scores)}")
+    print(f"Expected Max Toxicity: {np.mean(toxic_scores)} +- {np.std(toxic_scores)}")
+    print(f"Toxicity Probability: {(np.array(toxic_proportions) >= 1).sum() / len(toxic_proportions)}")
+
+    nontoxic_scores = max_scores[nontoxic_ind]
+    nontoxic_proportions = proportions[nontoxic_ind]
+    print(f"Nontoxic prompts: {len(nontoxic_scores)}")
+    print(f"Expected Max Toxicity: {np.mean(nontoxic_scores)} +- {np.std(nontoxic_scores)}")
+    print(f"Toxicity Probability: {(np.array(nontoxic_proportions) >= 1).sum() / len(nontoxic_proportions)}")
+
+main()

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/academic_paper_scripts/detxoify_lm/self_generation/selfgenerate-1.3b-unconditional.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+CHECKPOINT_PATH=$2          # Your model ckpt
+SHARE_DATA=$PWD             # current work dir
+VOCAB_FILE=gpt2-vocab.json  # Your gpt-2 vocab
+MERGE_FILE=gpt2-merges.txt  # Your gpt-2 merge file
+
+GPUS_PER_NODE=1
+# Change for multinode config
+MASTER_ADDR=localhost
+MASTER_PORT=$(($RANDOM + 1024))
+NNODES=1
+NODE_RANK=0
+WORLD_SIZE=$(($GPUS_PER_NODE*$NNODES))
+SEED=$3
+SUFFIX=$(basename $CHECKPOINT_PATH)
+save_dir=$SHARE_DATA/selfgeneration/unconditional_generation_$SUFFIX/
+mkdir -p $save_dir
+echo $save_dir/$SEED.out
+
+DISTRIBUTED_ARGS="--nproc_per_node $GPUS_PER_NODE --nnodes $NNODES --node_rank $NODE_RANK --master_addr $MASTER_ADDR --master_port $MASTER_PORT"
+
+python -m torch.distributed.run $DISTRIBUTED_ARGS examples/detxoify_lm/generate_samples_gpt.py \
+       --tensor-model-parallel-size 1 \
+       --num-layers 24 \
+       --hidden-size 2048 \
+       --load $CHECKPOINT_PATH \
+       --num-attention-heads 32 \
+       --max-position-embeddings 2048 \
+       --tokenizer-type GPT2BPETokenizer \
+       --fp16 \
+       --micro-batch-size 150 \
+       --seq-length 2048 \
+       --out-seq-length 1000 \
+       --temperature 1.0 \
+       --vocab-file $VOCAB_FILE \
+       --merge-file $MERGE_FILE \
+       --num-samples $1 \
+       --top_p 0.9 \
+       --max-tokens-to-oom 1200000 \
+       --genfile $save_dir/$SEED.out  \
+       --seed $SEED
+

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

@@ -0,0 +1,5 @@
+
+# Multi-Stage Prompting for Knowledgeable Dialogue Generation
+
+This directory contains all the scripts of multi-stage prompting for knowledgeable dialogue generation that includes data preparation, and knowledge and response generations. More details are available on [`knowledgeable task directory`](../../tasks/msdp).
+

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/academic_paper_scripts/msdp/data_processing.sh

@@ -0,0 +1,83 @@
+#!/bin/bash
+
+# Data preparation for our framework: preprocessing the WoW and WoI datasets
+# The datasets can be downloaded through the following links:
+# WoW: https://parl.ai/projects/wizard_of_wikipedia/
+# WoI: https://parl.ai/projects/sea/
+
+DIR=`pwd`
+# Before running the preprocessing, please download 
+# the wizard of wikipedia and wizard datasets
+WOW_DATA_FOLDER=<PATH_OF_WIZARD_OF_WIKIPEDIA_DATA_FOLDER>
+WOI_DATA_FOLDER=<PATH_OF_WIZARD_OF_INTERNET_DATA_FOLDER>
+
+# We provide examples for processing the raw data from Wizard of Wikipedia
+# Processing the train dataset (train.json)
+python ${DIR}/tasks/msdp/preprocessing.py \
+        --func process_wow_dataset \
+        --raw_file ${WOW_DATA_FOLDER}/train.json \
+        --processed_file ${WOW_DATA_FOLDER}/train_processed.txt
+
+# Processing test seen dataset (test_random_split.json)
+python ${DIR}/tasks/msdp/preprocessing.py \
+        --func process_wow_dataset \
+        --raw_file ${WOW_DATA_FOLDER}/test_random_split.json \
+        --processed_file ${WOW_DATA_FOLDER}/testseen_processed.txt \
+        --knwl_ref_file ${WOW_DATA_FOLDER}/output_testseen_knowledge_reference.txt \
+        --resp_ref_file ${WOW_DATA_FOLDER}/output_testseen_response_reference.txt
+
+# processing test unseen dataset (test_topic_split.json)
+python ${DIR}/tasks/msdp/preprocessing.py \
+        --func process_wow_dataset \
+        --raw_file ${WOW_DATA_FOLDER}/test_topic_split.json \
+        --processed_file ${WOW_DATA_FOLDER}/testunseen_processed.txt \
+        --knwl_ref_file ${WOW_DATA_FOLDER}/output_testunseen_knowledge_reference.txt \
+        --resp_ref_file ${WOW_DATA_FOLDER}/output_testunseen_response_reference.txt
+
+
+# We provide the following script to process the raw data from Wizard of Internet
+# Processing the test dataset (test.jsonl)
+python ${DIR}/tasks/msdp/preprocessing.py \
+        --func process_woi_dataset \
+        --raw_file ${WOI_DATA_FOLDER}/test.jsonl \
+        --processed_file ${WOI_DATA_FOLDER}/test_processed.txt \
+        --knwl_ref_file ${WOI_DATA_FOLDER}/output_test_knowledge_reference.txt \
+        --resp_ref_file ${WOI_DATA_FOLDER}/output_test_response_reference.txt
+
+
+# Get the knowledge generation prompts for the each test dataset in WoW and WoI
+MODEL_FILE=<PATH_OF_THE_FINETUNED_DPR_MODEL> 
+# WoW test seen
+python ${DIR}/tasks/msdp/preprocessing.py \
+        --func get_knwl_gen_prompts \
+        --test_file ${WOW_DATA_FOLDER}/testseen_processed.txt \
+        --train_file ${WOW_DATA_FOLDER}/train_processed.txt \
+        --model_file ${MODEL_FILE} \
+        --processed_file ${WOW_DATA_FOLDER}/output_testseen_knowledge_prompts.json \
+        --data_type wow_seen
+
+# WoW test unseen
+python ${DIR}/tasks/msdp/preprocessing.py \
+        --func get_knwl_gen_prompts \
+        --test_file ${WOW_DATA_FOLDER}/testunseen_processed.txt \
+        --train_file ${WOW_DATA_FOLDER}/train_processed.txt \
+        --model_file ${MODEL_FILE} \
+        --processed_file ${WOW_DATA_FOLDER}/output_testunseen_knowledge_prompts.json \
+        --data_type wow_unseen
+
+# WoI
+python ${DIR}/tasks/msdp/preprocessing.py \
+        --func get_knwl_gen_prompts \
+        --test_file ${WOI_DATA_FOLDER}/test_processed.txt \
+        --train_file ${WOW_DATA_FOLDER}/train_processed.txt \
+        --model_file ${MODEL_FILE} \
+        --processed_file ${WOI_DATA_FOLDER}/output_test_knowledge_prompts.json \
+        --data_type woi
+
+
+# Get the response generation prompts (can be applied for all the test datasets)
+python ${DIR}/tasks/msdp/preprocessing.py \
+        --func get_resp_gen_prompts \
+        --train_file ${WOW_DATA_FOLDER}/train_processed.txt \
+        --processed_file ${WOW_DATA_FOLDER}/output_response_prompts.txt
+

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/academic_paper_scripts/msdp/eval_knwl_generation.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+
+#########################
+# Evaluate the F1 scores.
+#########################
+
+WORLD_SIZE=1
+DISTRIBUTED_ARGS="--nproc_per_node $WORLD_SIZE \
+                  --nnodes 1 \
+                  --node_rank 0 \
+                  --master_addr localhost \
+                  --master_port 6000"
+                  
+MODEL_GEN_PATH=<PATH_OF_THE_KNOWLEDGE_GENERATION> \ 
+        (e.g., /testseen_knowledge_generations.txt)
+GROUND_TRUTH_PATH=<PATH_OF_THE_GROUND_TRUTH_KNOWLEDGE> \ 
+        (e.g., /testseen_knowledge_reference.txt)
+
+python -m torch.distributed.launch $DISTRIBUTED_ARGS ./tasks/msdp/main.py \
+        --num-layers 24 \
+        --hidden-size 1024 \
+        --num-attention-heads 16 \
+        --seq-length 2048 \
+        --max-position-embeddings 2048 \
+        --micro-batch-size 4 \
+        --task MSDP-EVAL-F1 \
+        --guess-file ${MODEL_GEN_PATH} \
+        --answer-file ${GROUND_TRUTH_PATH}
+
+
+############################################
+# Evaluate BLEU, METEOR, and ROUGE-L scores.
+############################################
+
+# We follow the nlg-eval (https://github.com/Maluuba/nlg-eval) to 
+# evaluate the BLEU, METEOR, and ROUGE-L scores. 
+
+# To evaluate on these metrics, please setup the environments based on 
+# the nlg-eval github, and run the corresponding evaluation commands.
+
+nlg-eval \
+    --hypothesis=<PATH_OF_THE_KNOWLEDGE_GENERATION> \
+    --references=<PATH_OF_THE_GROUND_TRUTH_KNOWLEDGE>

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/academic_paper_scripts/msdp/eval_resp_generation.sh

@@ -0,0 +1,64 @@
+#!/bin/bash
+
+#########################
+# Evaluate the F1 scores.
+#########################
+
+WORLD_SIZE=1
+DISTRIBUTED_ARGS="--nproc_per_node $WORLD_SIZE \
+                  --nnodes 1 \
+                  --node_rank 0 \
+                  --master_addr localhost \
+                  --master_port 6000"
+                  
+MODEL_GEN_PATH=<PATH_OF_THE_RESPONSE_GENERATION> \ 
+        (e.g., /testseen_response_generations.txt)
+GROUND_TRUTH_PATH=<PATH_OF_THE_GROUND_TRUTH_RESPONSE> \ 
+        (e.g., /testseen_response_reference.txt)
+
+python -m torch.distributed.launch $DISTRIBUTED_ARGS ./tasks/msdp/main.py \
+        --num-layers 24 \
+        --hidden-size 1024 \
+        --num-attention-heads 16 \
+        --seq-length 2048 \
+        --max-position-embeddings 2048 \
+        --micro-batch-size 4 \
+        --task MSDP-EVAL-F1 \
+        --guess-file ${MODEL_GEN_PATH} \
+        --answer-file ${GROUND_TRUTH_PATH}
+
+
+##########################
+# Evaluate the KF1 scores.
+##########################
+                  
+MODEL_GEN_PATH=<PATH_OF_THE_RESPONSE_GENERATION> \ 
+        (e.g., /testseen_response_generations.txt)
+GROUND_TRUTH_PATH=<PATH_OF_THE_GROUND_TRUTH_KNOWLEDGE> \ 
+        (e.g., /testseen_knowledge_reference.txt)
+
+python -m torch.distributed.launch $DISTRIBUTED_ARGS ./tasks/msdp/main.py \
+        --num-layers 24 \
+        --hidden-size 1024 \
+        --num-attention-heads 16 \
+        --seq-length 2048 \
+        --max-position-embeddings 2048 \
+        --micro-batch-size 4 \
+        --task MSDP-EVAL-F1 \
+        --guess-file ${MODEL_GEN_PATH} \
+        --answer-file ${GROUND_TRUTH_PATH}
+
+
+############################################
+# Evaluate BLEU, METEOR, and ROUGE-L scores.
+############################################
+
+# We follow the nlg-eval (https://github.com/Maluuba/nlg-eval) to 
+# evaluate the BLEU, METEOR, and ROUGE-L scores. 
+
+# To evaluate on these metrics, please setup the environments based on 
+# the nlg-eval github, and run the corresponding evaluation commands.
+
+nlg-eval \
+    --hypothesis=<PATH_OF_THE_RESPONSE_GENERATION> \
+    --references=<PATH_OF_THE_GROUND_TRUTH_RESPONSE>

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/academic_paper_scripts/msdp/prep_resp_gen.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+# Preparing the input file for the response generation (second-stage prompting)
+
+DIR=`pwd`
+
+TEST_FILE=<PATH_OF_PROCESSED_TEST_DATA> \
+        (e.g., /testseen_processed.txt)
+KNOWLEDGE_FILE=<PATH_OF_GENERATED_KNOWLEDGE_DATA> \
+        (e.g., /testseen_knowledge_generations.txt)
+PROCESSED_FILE=<PATH_OF_INPUT_FILE_FOR_RESPONSE_GENERATION> \
+        (e.g., /testseen_processed_with_generated_knowledge.txt)
+
+python ${DIR}/tasks/msdp/preprocessing.py \
+        --func prepare_input \
+        --test_file ${TEST_FILE} \
+        --knwl_gen_file ${KNOWLEDGE_FILE} \
+        --processed_file ${PROCESSED_FILE}

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/academic_paper_scripts/msdp/prompt_knwl_gen.sh

@@ -0,0 +1,46 @@
+#!/bin/bash
+
+# Stage-1: Prompt a pretrained language model to generate the context-relevant knowledge
+# The input contains prompts and current dialogue context, the output is the relevant knowledge
+# The size of the pretrained language model is 357M
+
+WORLD_SIZE=8
+
+DISTRIBUTED_ARGS="--nproc_per_node $WORLD_SIZE \
+                  --nnodes 1 \
+                  --node_rank 0 \
+                  --master_addr localhost \
+                  --master_port 6000"
+
+CHECKPOINT_PATH=<PATH_OF_LANGUAGE_MODEL> (e.g., /357m)
+VOCAB_PATH=<PATH_OF_VOCAB_FILE> (e.g., /gpt2-vocab.json)
+MERGE_PATH=<PATH_OF_MERGE_FILE> (e.g., /gpt2-merges.txt)
+INPUT_PATH=<PATH_OF_PROCESSED_TEST_DATA_FILE> \ 
+        (e.g., /testseen_processed.txt)
+PROMPT_PATH=<PATH_OF_KNOWLEDGE_GENERATION_PROMPTS> \
+        (e.g., /testseen_knowledge_prompts.json)
+OUTPUT_PATH=<PATH_OF_OUTPUT_GENERATION_FILE> \
+        (e.g., /testseen_knowledge_generations.txt)
+
+python -m torch.distributed.launch $DISTRIBUTED_ARGS ./tasks/msdp/main.py \
+        --num-layers 24 \
+        --hidden-size 1024 \
+        --num-attention-heads 16 \
+        --seq-length 2048 \
+        --max-position-embeddings 2048 \
+        --micro-batch-size 1 \
+        --vocab-file ${VOCAB_PATH} \
+        --merge-file ${MERGE_PATH} \
+        --load ${CHECKPOINT_PATH} \
+        --fp16 \
+        --DDP-impl torch \
+        --tokenizer-type GPT2BPETokenizer \
+        --sample-input-file ${INPUT_PATH} \
+        --sample-output-file ${OUTPUT_PATH} \
+        --prompt-file ${PROMPT_PATH} \
+        --prompt-type knowledge \
+        --num-prompt-examples 10 \
+        --task MSDP-PROMPT 
+
+# NOTE: If you use api for the model generation, please use 
+# the "--api-prompt" flag (setting this value as True). 

tasks/kfc/wro-megatron-moe-routing-fused-triton-loop16/task/environment/repo/examples/academic_paper_scripts/msdp/prompt_resp_gen.sh

@@ -0,0 +1,46 @@
+#!/bin/bash
+
+# Stage-2: Prompt a pretrained language model to generate the corresponding response
+# The input contains prompts, current dialogue context, and generated knowledge in Stage-1
+# The output is the corresponding response.
+# The size of the pretrained language model is 357M
+
+WORLD_SIZE=8
+
+DISTRIBUTED_ARGS="--nproc_per_node $WORLD_SIZE \
+                  --nnodes 1 \
+                  --node_rank 0 \
+                  --master_addr localhost \
+                  --master_port 6000"
+
+CHECKPOINT_PATH=<PATH_OF_LANGUAGE_MODEL> (e.g., /357m)
+VOCAB_PATH=<PATH_OF_VOCAB_FILE> (e.g., /gpt2-vocab.json)
+MERGE_PATH=<PATH_OF_MERGE_FILE> (e.g., /gpt2-merges.txt)
+INPUT_PATH=<PATH_OF_INPUT_TEST_DATA_FILE> (e.g., /testseen_processed.txt)
+PROMPT_PATH=<PATH_OF_RESPONSE_GENERATION_PROMPTS> \
+        (e.g., /response_prompts.txt)
+OUTPUT_PATH=<PATH_OF_OUTPUT_GENERATION_FILE> \
+        (e.g., /output_testseen_response_generations.txt)
+
+python -m torch.distributed.launch $DISTRIBUTED_ARGS ./tasks/msdp/main.py \
+        --num-layers 24 \
+        --hidden-size 1024 \
+        --num-attention-heads 16 \
+        --seq-length 2048 \
+        --max-position-embeddings 2048 \
+        --micro-batch-size 1 \
+        --vocab-file ${VOCAB_PATH} \
+        --merge-file ${MERGE_PATH} \
+        --load ${CHECKPOINT_PATH} \
+        --fp16 \
+        --DDP-impl torch \
+        --tokenizer-type GPT2BPETokenizer \
+        --sample-input-file ${INPUT_PATH} \
+        --sample-output-file ${OUTPUT_PATH} \
+        --prompt-file ${PROMPT_PATH} \
+        --prompt-type response \
+        --num-prompt-examples 20 \
+        --task MSDP-PROMPT 
+
+# NOTE: If you use api for the model generation, please use 
+# the "--api-prompt" flag (setting this value as True).