Add files using upload-large-folder tool

scripts/run_1.14G_dp128_tp2_pp1_acc2_mbs8_seq2048_zero1_tpmodeRED_vocab32k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp128_tp2_pp1_acc2_mbs8_seq2048_zero1_tpmodeRED_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=32                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp128_tp2_pp1_acc2_mbs8_seq2048_zero1_tpmodeRED_vocab32k.yaml

scripts/run_1.14G_dp16_tp2_pp1_acc2_mbs16_seq2048_zero1_tpmodeALL_vocab32k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp16_tp2_pp1_acc2_mbs16_seq2048_zero1_tpmodeALL_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=4                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp16_tp2_pp1_acc2_mbs16_seq2048_zero1_tpmodeALL_vocab32k.yaml

scripts/run_1.14G_dp16_tp2_pp1_acc64_mbs2_seq2048_zero1_tpmodeALL_vocab32k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp16_tp2_pp1_acc64_mbs2_seq2048_zero1_tpmodeALL_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=4                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp16_tp2_pp1_acc64_mbs2_seq2048_zero1_tpmodeALL_vocab32k.yaml

scripts/run_1.14G_dp16_tp32_pp1_acc16_mbs2_seq2048_zero1_tpmodeALL_vocab32k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp16_tp32_pp1_acc16_mbs2_seq2048_zero1_tpmodeALL_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=64                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp16_tp32_pp1_acc16_mbs2_seq2048_zero1_tpmodeALL_vocab32k.yaml

scripts/run_1.14G_dp2_tp16_pp1_acc32_mbs8_seq8192_zero1_tpmodeRED_vocab32k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp2_tp16_pp1_acc32_mbs8_seq8192_zero1_tpmodeRED_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=4                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp2_tp16_pp1_acc32_mbs8_seq8192_zero1_tpmodeRED_vocab32k.yaml

scripts/run_1.14G_dp2_tp1_pp4_acc16_mbs16_seq8192_zero1_tpmodeRED_vocab32k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp2_tp1_pp4_acc16_mbs16_seq8192_zero1_tpmodeRED_vocab32k    # Job name
+#SBATCH --time=00:15:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=1                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp2_tp1_pp4_acc16_mbs16_seq8192_zero1_tpmodeRED_vocab32k.yaml

scripts/run_1.14G_dp2_tp8_pp1_acc32_mbs8_seq2048_zero1_tpmodeALL_vocab32k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp2_tp8_pp1_acc32_mbs8_seq2048_zero1_tpmodeALL_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=2                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp2_tp8_pp1_acc32_mbs8_seq2048_zero1_tpmodeALL_vocab32k.yaml

scripts/run_1.14G_dp32_tp16_pp1_acc8_mbs2_seq8192_zero1_tpmodeRED_vocab32k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp32_tp16_pp1_acc8_mbs2_seq8192_zero1_tpmodeRED_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=64                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp32_tp16_pp1_acc8_mbs2_seq8192_zero1_tpmodeRED_vocab32k.yaml

scripts/run_1.14G_dp32_tp1_pp2_acc1_mbs1_seq32768_zero1_tpmodeRED_vocab32k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp32_tp1_pp2_acc1_mbs1_seq32768_zero1_tpmodeRED_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=8                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp32_tp1_pp2_acc1_mbs1_seq32768_zero1_tpmodeRED_vocab32k.yaml

scripts/run_1.14G_dp4_tp16_pp1_acc8_mbs16_seq2048_zero1_tpmodeRED_vocab32k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp4_tp16_pp1_acc8_mbs16_seq2048_zero1_tpmodeRED_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=8                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp4_tp16_pp1_acc8_mbs16_seq2048_zero1_tpmodeRED_vocab32k.yaml

scripts/run_1.14G_dp4_tp2_pp64_acc1_mbs1_seq2048_zero0_tpmodeRED_l16_h2048_heads32.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp4_tp2_pp64_acc1_mbs1_seq2048_zero0_tpmodeRED_l16_h2048_heads32    # Job name
+#SBATCH --time=00:15:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=64                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp4_tp2_pp64_acc1_mbs1_seq2048_zero0_tpmodeRED_l16_h2048_heads32.yaml

scripts/run_1.14G_dp4_tp4_pp1_acc32_mbs1_seq32768_zero1_tpmodeRED_vocab32k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp4_tp4_pp1_acc32_mbs1_seq32768_zero1_tpmodeRED_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=2                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp4_tp4_pp1_acc32_mbs1_seq32768_zero1_tpmodeRED_vocab32k.yaml

scripts/run_1.14G_dp4_tp64_pp1_acc2_mbs64_seq2048_zero1_tpmodeALL_vocab32k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp4_tp64_pp1_acc2_mbs64_seq2048_zero1_tpmodeALL_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=32                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp4_tp64_pp1_acc2_mbs64_seq2048_zero1_tpmodeALL_vocab32k.yaml

scripts/run_1.14G_dp64_tp1_pp1_acc2_mbs1_seq32768_zero1_tpmodeRED_vocab32k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp64_tp1_pp1_acc2_mbs1_seq32768_zero1_tpmodeRED_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=8                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp64_tp1_pp1_acc2_mbs1_seq32768_zero1_tpmodeRED_vocab32k.yaml

scripts/run_1.14G_dp8_tp16_pp1_acc1_mbs256_seq2048_zero1_tpmodeALL_vocab32k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp8_tp16_pp1_acc1_mbs256_seq2048_zero1_tpmodeALL_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=16                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp8_tp16_pp1_acc1_mbs256_seq2048_zero1_tpmodeALL_vocab32k.yaml

scripts/run_1.14G_dp8_tp16_pp1_acc4_mbs1_seq32768_zero1_tpmodeALL_vocab32k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp8_tp16_pp1_acc4_mbs1_seq32768_zero1_tpmodeALL_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=16                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp8_tp16_pp1_acc4_mbs1_seq32768_zero1_tpmodeALL_vocab32k.yaml

scripts/run_1.14G_dp8_tp1_pp1_acc128_mbs2_seq2048_zero1_tpmodeRED_vocab32k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp8_tp1_pp1_acc128_mbs2_seq2048_zero1_tpmodeRED_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=1                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp8_tp1_pp1_acc128_mbs2_seq2048_zero1_tpmodeRED_vocab32k.yaml

scripts/run_1.14G_dp8_tp2_pp1_acc4_mbs16_seq2048_zero1_tpmodeALL_vocab32k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp8_tp2_pp1_acc4_mbs16_seq2048_zero1_tpmodeALL_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=2                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp8_tp2_pp1_acc4_mbs16_seq2048_zero1_tpmodeALL_vocab32k.yaml

scripts/run_1.14G_dp8_tp32_pp1_acc2_mbs32_seq8192_zero1_tpmodeALL_vocab32k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp8_tp32_pp1_acc2_mbs32_seq8192_zero1_tpmodeALL_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=32                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp8_tp32_pp1_acc2_mbs32_seq8192_zero1_tpmodeALL_vocab32k.yaml

scripts/run_1.14G_dp8_tp4_pp1_acc2_mbs32_seq8192_zero1_tpmodeRED_vocab32k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp8_tp4_pp1_acc2_mbs32_seq8192_zero1_tpmodeRED_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=4                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp8_tp4_pp1_acc2_mbs32_seq8192_zero1_tpmodeRED_vocab32k.yaml

scripts/run_1.14G_dp8_tp64_pp1_acc8_mbs32_seq2048_zero1_tpmodeALL_vocab32k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp8_tp64_pp1_acc8_mbs32_seq2048_zero1_tpmodeALL_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=64                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp8_tp64_pp1_acc8_mbs32_seq2048_zero1_tpmodeALL_vocab32k.yaml

scripts/run_1.14G_dp8_tp8_pp1_acc2_mbs2_seq32768_zero1_tpmodeRED_vocab32k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.14G_dp8_tp8_pp1_acc2_mbs2_seq32768_zero1_tpmodeRED_vocab32k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=8                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.14G_dp8_tp8_pp1_acc2_mbs2_seq32768_zero1_tpmodeRED_vocab32k.yaml

scripts/run_1.34G_dp128_tp1_pp1_acc8_mbs2_seq2048_zero1_tpmodeRED_vocab131k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp128_tp1_pp1_acc8_mbs2_seq2048_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=16                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp128_tp1_pp1_acc8_mbs2_seq2048_zero1_tpmodeRED_vocab131k.yaml

scripts/run_1.34G_dp16_tp2_pp1_acc8_mbs1_seq32768_zero1_tpmodeALL_vocab131k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp16_tp2_pp1_acc8_mbs1_seq32768_zero1_tpmodeALL_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=4                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp16_tp2_pp1_acc8_mbs1_seq32768_zero1_tpmodeALL_vocab131k.yaml

scripts/run_1.34G_dp16_tp4_pp1_acc2_mbs16_seq2048_zero1_tpmodeRED_vocab131k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp16_tp4_pp1_acc2_mbs16_seq2048_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=8                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp16_tp4_pp1_acc2_mbs16_seq2048_zero1_tpmodeRED_vocab131k.yaml

scripts/run_1.34G_dp256_tp1_pp1_acc2_mbs1_seq2048_zero1_tpmodeRED_vocab131k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp256_tp1_pp1_acc2_mbs1_seq2048_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=32                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp256_tp1_pp1_acc2_mbs1_seq2048_zero1_tpmodeRED_vocab131k.yaml

scripts/run_1.34G_dp2_tp1_pp8_acc8_mbs128_seq2048_zero1_tpmodeRED_vocab131k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp2_tp1_pp8_acc8_mbs128_seq2048_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:15:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=2                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp2_tp1_pp8_acc8_mbs128_seq2048_zero1_tpmodeRED_vocab131k.yaml

scripts/run_1.34G_dp2_tp256_pp1_acc1_mbs256_seq2048_zero1_tpmodeALL_vocab131k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp2_tp256_pp1_acc1_mbs256_seq2048_zero1_tpmodeALL_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=64                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp2_tp256_pp1_acc1_mbs256_seq2048_zero1_tpmodeALL_vocab131k.yaml

scripts/run_1.34G_dp2_tp256_pp1_acc4_mbs64_seq8192_zero1_tpmodeRED_vocab131k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp2_tp256_pp1_acc4_mbs64_seq8192_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=64                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp2_tp256_pp1_acc4_mbs64_seq8192_zero1_tpmodeRED_vocab131k.yaml

scripts/run_1.34G_dp2_tp64_pp1_acc32_mbs8_seq8192_zero1_tpmodeALL_vocab131k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp2_tp64_pp1_acc32_mbs8_seq8192_zero1_tpmodeALL_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=16                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp2_tp64_pp1_acc32_mbs8_seq8192_zero1_tpmodeALL_vocab131k.yaml

scripts/run_1.34G_dp2_tp64_pp1_acc8_mbs8_seq8192_zero1_tpmodeALL_vocab131k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp2_tp64_pp1_acc8_mbs8_seq8192_zero1_tpmodeALL_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=16                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp2_tp64_pp1_acc8_mbs8_seq8192_zero1_tpmodeALL_vocab131k.yaml

scripts/run_1.34G_dp2_tp8_pp1_acc32_mbs2_seq32768_zero1_tpmodeALL_vocab131k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp2_tp8_pp1_acc32_mbs2_seq32768_zero1_tpmodeALL_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=2                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp2_tp8_pp1_acc32_mbs2_seq32768_zero1_tpmodeALL_vocab131k.yaml

scripts/run_1.34G_dp2_tp8_pp2_acc16_mbs8_seq4096_zero1_tpmodeRED_vocab131k.sh

@@ -0,0 +1,159 @@
+#!/bin/bash
+#SBATCH --job-name=bench_1.34G_dp2_tp8_pp2_acc16_mbs8_seq4096_zero1_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=01:10:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=4                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+# Unset FI_PROVIDER to avoid potential libfabric provider issues
+# unset FI_PROVIDER
+
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=INFO # INFO, WARN
+# export NCCL_DEBUG_SUBSYS=ALL
+# export CUDA_LAUNCH_BLOCKING=1
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# export TORCH_NCCL_USE_COMM_NONBLOCKING=1
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+# debug
+export TORCH_DISTRIBUTED_DEBUG=DETAIL
+
+# export NCCL_P2P_LEVEL=NVL
+# export CUDA_LAUNCH_BLOCKING=1
+# export NCCL_IB_CUDA_SUPPORT=0 # Disable RDMA
+# export NCCL_NET_GDR_LEVEL=LOC
+# Test Script - save as test_comm.sh
+
+# Test 1 - Force TCP
+# echo "Running with TCP only..."
+# export NCCL_P2P_LEVEL=LOC
+
+# # Match bandwidth patterns
+# export NCCL_MAX_NCHANNELS=2
+# export NCCL_MIN_NCHANNELS=2
+
+
+# export NCCL_NET_GDR_LEVEL=LOC # Disable RDMA
+# export NCCL_SHM_DISABLE=0 # disables the Shared Memory (SHM) transport
+# export NCCL_IB_DISABLE=0 # disables the InfiniBand (IB) transport
+# export NCCL_IB_TIMEOUT=60  # 20 = ~4 seconds , 21 = ~8 seconds , 22 = ~16 seconds
+# export NCCL_IB_RETRY_CNT=7  # Increase retry count as well
+
+# Force SHM
+# export NCCL_NET_PLUGIN=none # fixes hang but doesnt work multinode
+# export NCCL_SOCKET_NTHREADS=1
+# export FI_PROVIDER="tcp" 
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_1.34G_dp2_tp8_pp2_acc16_mbs8_seq4096_zero1_tpmodeRED_vocab131k"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_1.34G_dp2_tp8_pp2_acc16_mbs8_seq4096_zero1_tpmodeRED_vocab131k.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_1.34G_dp2_tp8_pp2_acc16_mbs8_seq4096_zero1_tpmodeRED_vocab131k.yaml
+fi

scripts/run_1.34G_dp32_tp16_pp1_acc1_mbs4_seq32768_zero1_tpmodeALL_vocab131k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp32_tp16_pp1_acc1_mbs4_seq32768_zero1_tpmodeALL_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=64                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp32_tp16_pp1_acc1_mbs4_seq32768_zero1_tpmodeALL_vocab131k.yaml

scripts/run_1.34G_dp32_tp16_pp1_acc2_mbs32_seq2048_zero1_tpmodeRED_vocab131k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp32_tp16_pp1_acc2_mbs32_seq2048_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=64                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp32_tp16_pp1_acc2_mbs32_seq2048_zero1_tpmodeRED_vocab131k.yaml

scripts/run_1.34G_dp32_tp16_pp1_acc4_mbs1_seq32768_zero1_tpmodeALL_vocab131k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp32_tp16_pp1_acc4_mbs1_seq32768_zero1_tpmodeALL_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=64                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp32_tp16_pp1_acc4_mbs1_seq32768_zero1_tpmodeALL_vocab131k.yaml

scripts/run_1.34G_dp32_tp1_pp2_acc2_mbs32_seq2048_zero1_tpmodeRED_vocab131k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp32_tp1_pp2_acc2_mbs32_seq2048_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=8                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp32_tp1_pp2_acc2_mbs32_seq2048_zero1_tpmodeRED_vocab131k.yaml

scripts/run_1.34G_dp4_tp1_pp2_acc2_mbs16_seq8192_zero1_tpmodeRED_vocab131k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp4_tp1_pp2_acc2_mbs16_seq8192_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=1                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp4_tp1_pp2_acc2_mbs16_seq8192_zero1_tpmodeRED_vocab131k.yaml

scripts/run_1.34G_dp4_tp2_pp1_acc4_mbs8_seq8192_zero1_tpmodeRED_vocab131k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp4_tp2_pp1_acc4_mbs8_seq8192_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=1                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp4_tp2_pp1_acc4_mbs8_seq8192_zero1_tpmodeRED_vocab131k.yaml

scripts/run_1.34G_dp4_tp2_pp1_acc8_mbs64_seq2048_zero1_tpmodeRED_vocab131k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp4_tp2_pp1_acc8_mbs64_seq2048_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=1                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp4_tp2_pp1_acc8_mbs64_seq2048_zero1_tpmodeRED_vocab131k.yaml

scripts/run_1.34G_dp4_tp32_pp1_acc32_mbs4_seq8192_zero1_tpmodeALL_vocab131k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp4_tp32_pp1_acc32_mbs4_seq8192_zero1_tpmodeALL_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=16                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp4_tp32_pp1_acc32_mbs4_seq8192_zero1_tpmodeALL_vocab131k.yaml

scripts/run_1.34G_dp64_tp2_pp2_acc4_mbs1_seq4096_zero1_tpmodeRED_vocab131k.sh

@@ -0,0 +1,159 @@
+#!/bin/bash
+#SBATCH --job-name=bench_1.34G_dp64_tp2_pp2_acc4_mbs1_seq4096_zero1_tpmodeRED_vocab131k   # Job name
+#SBATCH --time=01:10:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=32                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+#SBATCH --wait-all-nodes=1        # fail if any node is not ready
+
+# run using
+# sbatch --nodes=1 run_multinode.sh
+# or
+# SALLOC_JOBID=13482276 NNODES=1 bash run_multinode.sh
+
+set -x -e
+
+# If not running under SLURM, set default SLURM environment variables
+if [ -z "${SLURM_JOB_ID}" ]; then
+    if [ -z "${SALLOC_JOBID}" ]; then
+        echo "Error: SALLOC_JOBID environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    if [ -z "${NNODES}" ]; then
+        echo "Error: NNODES environment variable is required but not set. Please run this script within an salloc session."
+        exit 1
+    fi
+    export SALLOC_MODE=1
+    export SLURM_JOB_ID=$SALLOC_JOBID
+    export SLURM_NNODES=$NNODES
+    export SLURM_JOB_NODELIST=$(squeue -j $SALLOC_JOBID -h -o "%N")
+fi
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+# Unset FI_PROVIDER to avoid potential libfabric provider issues
+# unset FI_PROVIDER
+
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+if [ -z "${SALLOC_MODE}" ]; then # sbatch mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+
+else # srun mode
+    export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n$SLURM_NNODES`
+fi
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+export NCCL_DEBUG=INFO # INFO, WARN
+# export NCCL_DEBUG_SUBSYS=ALL
+# export CUDA_LAUNCH_BLOCKING=1
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+export WANDB_MODE=disabled
+
+# export TORCH_NCCL_USE_COMM_NONBLOCKING=1
+
+# Trying to avoid hangs
+export TORCH_NCCL_ASYNC_ERROR_HANDLING=1
+
+# debug
+export TORCH_DISTRIBUTED_DEBUG=DETAIL
+
+# export NCCL_P2P_LEVEL=NVL
+# export CUDA_LAUNCH_BLOCKING=1
+# export NCCL_IB_CUDA_SUPPORT=0 # Disable RDMA
+# export NCCL_NET_GDR_LEVEL=LOC
+# Test Script - save as test_comm.sh
+
+# Test 1 - Force TCP
+# echo "Running with TCP only..."
+# export NCCL_P2P_LEVEL=LOC
+
+# # Match bandwidth patterns
+# export NCCL_MAX_NCHANNELS=2
+# export NCCL_MIN_NCHANNELS=2
+
+
+# export NCCL_NET_GDR_LEVEL=LOC # Disable RDMA
+# export NCCL_SHM_DISABLE=0 # disables the Shared Memory (SHM) transport
+# export NCCL_IB_DISABLE=0 # disables the InfiniBand (IB) transport
+# export NCCL_IB_TIMEOUT=60  # 20 = ~4 seconds , 21 = ~8 seconds , 22 = ~16 seconds
+# export NCCL_IB_RETRY_CNT=7  # Increase retry count as well
+
+# Force SHM
+# export NCCL_NET_PLUGIN=none # fixes hang but doesnt work multinode
+# export NCCL_SOCKET_NTHREADS=1
+# export FI_PROVIDER="tcp" 
+
+# Print GPU topology information
+if [ -z "${SALLOC_MODE}" ]; then
+    echo "=== GPU Topology ==="
+    nvidia-smi topo -m
+    echo "=================="
+    export SRUN_ALLOC_ARGS=""
+else
+    export JOBNAME="bench_1.34G_dp64_tp2_pp2_acc4_mbs1_seq4096_zero1_tpmodeRED_vocab131k"
+    export OUTPUT_FILE="/fsx/nouamane/projects/nanotron/logs/$SLURM_JOB_ID-$(date +%Y-%m-%d-%H-%M-%S)-$JOBNAME.out"
+    export SRUN_ALLOC_ARGS="--jobid=$SLURM_JOB_ID --nodes=$NNODES --gres=gpu:$GPUS_PER_NODE --time=01:02:00 --job-name=$JOBNAME"
+fi
+
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun in background
+if [ -n "${SALLOC_MODE}" ]; then # srun mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_1.34G_dp64_tp2_pp2_acc4_mbs1_seq4096_zero1_tpmodeRED_vocab131k.yaml > $OUTPUT_FILE 2>&1 &
+    # Store the process ID
+    SRUN_PID=$!
+    echo "Job started in background with PID: $SRUN_PID" | tee -a $OUTPUT_FILE
+
+    # Optionally, you can add:
+    echo "To check job status: ps -p $SRUN_PID" | tee -a $OUTPUT_FILE
+    echo "To kill the job: kill $SRUN_PID" | tee -a $OUTPUT_FILE
+
+else # sbatch mode
+    srun $SRUN_ALLOC_ARGS --wait=0 --kill-on-bad-exit=1 torchrun \
+        --nnodes=$NNODES \
+        --nproc_per_node=$GPUS_PER_NODE \
+        --rdzv_id=$SLURM_JOB_ID \
+        --rdzv_backend=c10d \
+        --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+        --max_restarts 0 \
+        --rdzv_conf timeout=60 \
+        /fsx/nouamane/projects/nanotron/run_train.py \
+        --config-file benchmark/configs/config_1.34G_dp64_tp2_pp2_acc4_mbs1_seq4096_zero1_tpmodeRED_vocab131k.yaml
+fi

scripts/run_1.34G_dp64_tp8_pp1_acc8_mbs4_seq2048_zero1_tpmodeRED_vocab131k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp64_tp8_pp1_acc8_mbs4_seq2048_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=64                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp64_tp8_pp1_acc8_mbs4_seq2048_zero1_tpmodeRED_vocab131k.yaml

scripts/run_1.34G_dp8_tp16_pp1_acc64_mbs4_seq2048_zero1_tpmodeRED_vocab131k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp8_tp16_pp1_acc64_mbs4_seq2048_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=16                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp8_tp16_pp1_acc64_mbs4_seq2048_zero1_tpmodeRED_vocab131k.yaml

scripts/run_1.34G_dp8_tp1_pp1_acc4_mbs64_seq2048_zero1_tpmodeRED_vocab131k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp8_tp1_pp1_acc4_mbs64_seq2048_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=1                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp8_tp1_pp1_acc4_mbs64_seq2048_zero1_tpmodeRED_vocab131k.yaml

scripts/run_1.34G_dp8_tp2_pp1_acc4_mbs16_seq2048_zero1_tpmodeRED_vocab131k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp8_tp2_pp1_acc4_mbs16_seq2048_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=2                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp8_tp2_pp1_acc4_mbs16_seq2048_zero1_tpmodeRED_vocab131k.yaml

scripts/run_1.34G_dp8_tp4_pp1_acc4_mbs16_seq2048_zero1_tpmodeALL_vocab131k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp8_tp4_pp1_acc4_mbs16_seq2048_zero1_tpmodeALL_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=4                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp8_tp4_pp1_acc4_mbs16_seq2048_zero1_tpmodeALL_vocab131k.yaml

scripts/run_1.34G_dp8_tp4_pp1_acc8_mbs32_seq2048_zero1_tpmodeRED_vocab131k.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_1.34G_dp8_tp4_pp1_acc8_mbs32_seq2048_zero1_tpmodeRED_vocab131k    # Job name
+#SBATCH --time=00:02:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=4                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_1.34G_dp8_tp4_pp1_acc8_mbs32_seq2048_zero1_tpmodeRED_vocab131k.yaml

scripts/run_3.27G_dp8_tp2_pp32_acc1_mbs1_seq2048_zero0_tpmodeRED_l28_h3072_heads24.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_3.27G_dp8_tp2_pp32_acc1_mbs1_seq2048_zero0_tpmodeRED_l28_h3072_heads24    # Job name
+#SBATCH --time=00:15:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=64                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# # Disable EFA by changing the provider to tcp
+# export FI_PROVIDER=tcp
+
+# # Optionally, you can also unset these EFA-related variables
+# unset FI_EFA_FORK_SAFE
+# unset FI_EFA_ENABLE_SHM_TRANSFER
+
+# # If you want to ensure NCCL uses TCP
+# export NCCL_IB_DISABLE=1
+# export NCCL_SOCKET_IFNAME=eth0
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_3.27G_dp8_tp2_pp32_acc1_mbs1_seq2048_zero0_tpmodeRED_l28_h3072_heads24.yaml

scripts/run_3.56G_dp32_tp4_pp1_acc8_mbs1_seq2048_zero0_l28_h3072_heads24.sh

@@ -0,0 +1,57 @@
+#!/bin/bash
+
+#SBATCH --job-name=bench_3.56G_dp32_tp4_pp1_acc8_mbs1_seq2048_zero0_l28_h3072_heads24    # Job name
+#SBATCH --time=00:15:00
+#SBATCH --partition=hopper-prod
+#SBATCH --qos=high
+
+#SBATCH -o /fsx/nouamane/projects/nanotron/logs/%j-%x.out
+
+#SBATCH --nodes=16                 # Number of nodes (modify as needed)
+#SBATCH --ntasks-per-node=1       # Number of tasks per node
+#SBATCH --cpus-per-task=60         # CPU cores per task
+#SBATCH --gres=gpu:8              # Number of GPUs per node
+#SBATCH --exclusive               # Exclusive use of nodes
+
+set -x -e
+
+# Load any necessary modules for your system
+source /etc/profile.d/modules.sh # for some reason module isn't loaded
+module load cuda/12.1
+
+# Activate your conda environment if needed
+source /fsx/nouamane/miniconda/bin/activate
+conda activate 2-1-cu121
+export PATH=/fsx/nouamane/miniconda/envs/2-1-cu121/bin:$PATH
+
+# Get the node names from SLURM
+export NODELIST=`scontrol show hostnames $SLURM_JOB_NODELIST`
+export MASTER_NODE=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n1`
+export MASTER_PORT=12356
+
+# Calculate total number of processes
+export NNODES=$SLURM_NNODES
+export GPUS_PER_NODE=8
+export WORLD_SIZE=$(($NNODES * $GPUS_PER_NODE))
+
+# Set some environment variables for better distributed training
+export CUDA_DEVICE_MAX_CONNECTIONS=1
+# export NCCL_DEBUG=INFO
+
+# Nanotron specific
+export NANOTRON_BENCHMARK=1
+
+# Print some debugging information
+echo "Master node: $MASTER_NODE"
+echo "All nodes: $NODELIST"
+echo "World size: $WORLD_SIZE"
+
+# Launch the training script using srun
+srun torchrun \
+    --nnodes=$NNODES \
+    --nproc_per_node=$GPUS_PER_NODE \
+    --rdzv_id=$SLURM_JOB_ID \
+    --rdzv_backend=c10d \
+    --rdzv_endpoint=$MASTER_NODE:$MASTER_PORT \
+    run_train.py \
+    --config-file benchmark/configs/config_3.56G_dp32_tp4_pp1_acc8_mbs1_seq2048_zero0_l28_h3072_heads24.yaml