Add files using upload-large-folder tool

jz/configs/dec_only_t5/decoder_only_t5-large.json

@@ -0,0 +1,22 @@
+{
+    "architectures": [
+      "DecoderOnlyT5LMHeadModel"
+    ],
+    "d_ff": 5120,
+    "d_kv": 64,
+    "d_model": 1280,
+    "dropout_rate": 0.1,
+    "eos_token_id": 1,
+    "initializer_factor": 1.0,
+    "is_encoder_decoder": true,
+    "layer_norm_epsilon": 1e-06,
+    "model_type": "decoder_only_t5",
+    "num_heads": 20,
+    "num_layers": 36,
+    "output_past": true,
+    "pad_token_id": 0,
+    "relative_attention_num_buckets": 64,
+    "task_specific_params": {
+    },
+    "vocab_size": 32128
+  }

jz/configs/dec_only_t5/decoder_only_t5-medium.json

@@ -0,0 +1,22 @@
+{
+    "architectures": [
+      "DecoderOnlyT5LMHeadModel"
+    ],
+    "d_ff": 4096,
+    "d_kv": 64,
+    "d_model": 1024,
+    "dropout_rate": 0.1,
+    "eos_token_id": 1,
+    "initializer_factor": 1.0,
+    "is_encoder_decoder": true,
+    "layer_norm_epsilon": 1e-06,
+    "model_type": "decoder_only_t5",
+    "num_heads": 16,
+    "num_layers": 24,
+    "output_past": true,
+    "pad_token_id": 0,
+    "relative_attention_num_buckets": 64,
+    "task_specific_params": {
+    },
+    "vocab_size": 32128
+  }

jz/configs/dec_only_t5/decoder_only_t5-small.json

@@ -0,0 +1,22 @@
+{
+    "architectures": [
+      "DecoderOnlyT5LMHeadModel"
+    ],
+    "d_ff": 3072,
+    "d_kv": 64,
+    "d_model": 768,
+    "dropout_rate": 0.1,
+    "eos_token_id": 1,
+    "initializer_factor": 1.0,
+    "is_encoder_decoder": false,
+    "layer_norm_epsilon": 1e-06,
+    "model_type": "decoder_only_t5",
+    "num_heads": 12,
+    "num_layers": 12,
+    "output_past": true,
+    "pad_token_id": 0,
+    "relative_attention_num_buckets": 64,
+    "task_specific_params": {
+    },
+    "vocab_size": 32128
+  }

jz/configs/dec_only_t5/decoder_only_t5-tiny.json

@@ -0,0 +1,22 @@
+{
+    "architectures": [
+      "DecoderOnlyT5LMHeadModel"
+    ],
+    "d_ff": 2048,
+    "d_kv": 64,
+    "d_model": 512,
+    "dropout_rate": 0.1,
+    "eos_token_id": 1,
+    "initializer_factor": 1.0,
+    "is_encoder_decoder": false,
+    "layer_norm_epsilon": 1e-06,
+    "model_type": "decoder_only_t5",
+    "num_heads": 8,
+    "num_layers": 6,
+    "output_past": true,
+    "pad_token_id": 0,
+    "relative_attention_num_buckets": 64,
+    "task_specific_params": {
+    },
+    "vocab_size": 32128
+  }

jz/configs/dec_only_t5/decoder_only_t5-xl.json

@@ -0,0 +1,22 @@
+{
+    "architectures": [
+      "DecoderOnlyT5LMHeadModel"
+    ],
+    "d_ff": 6400,
+    "d_kv": 64,
+    "d_model": 1600,
+    "dropout_rate": 0.1,
+    "eos_token_id": 1,
+    "initializer_factor": 1.0,
+    "is_encoder_decoder": true,
+    "layer_norm_epsilon": 1e-06,
+    "model_type": "decoder_only_t5",
+    "num_heads": 25,
+    "num_layers": 48,
+    "output_past": true,
+    "pad_token_id": 0,
+    "relative_attention_num_buckets": 64,
+    "task_specific_params": {
+    },
+    "vocab_size": 32128
+  }

jz/configs/deepspeed/README.md

@@ -0,0 +1 @@
+# Deepspeed configs

jz/configs/deepspeed/ds_zero0.json

@@ -0,0 +1,33 @@
+{
+    "fp16": {
+        "enabled": "auto",
+        "loss_scale": 0,
+        "loss_scale_window": 1000,
+        "initial_scale_power": 16,
+        "hysteresis": 2,
+        "min_loss_scale": 1
+    },
+    "optimizer": {
+        "type": "AdamW",
+        "params": {
+            "lr": "auto",
+            "betas": "auto",
+            "eps": "auto",
+            "weight_decay": "auto"
+        }
+    },
+    "scheduler": {
+        "type": "WarmupLR",
+        "params": {
+            "warmup_min_lr": "auto",
+            "warmup_max_lr": "auto",
+            "warmup_num_steps": "auto"
+        }
+    },
+    "gradient_accumulation_steps": "auto",
+    "gradient_clipping": "auto",
+    "steps_per_print": 2000,
+    "train_batch_size": "auto",
+    "train_micro_batch_size_per_gpu": "auto",
+    "wall_clock_breakdown": false
+}

jz/configs/deepspeed/ds_zero2.json

@@ -0,0 +1,48 @@
+{
+    "fp16": {
+	    "enabled": true,
+        "loss_scale": 0,
+        "loss_scale_window": 1000,
+        "initial_scale_power": 32,
+        "hysteresis": 2,
+        "min_loss_scale": 1
+    },
+
+    "optimizer": {
+        "type": "AdamW",
+        "params": {
+            "lr": "auto",
+            "betas": "auto",
+            "eps": "auto",
+            "weight_decay": "auto"
+        }
+    },
+
+    "scheduler": {
+        "type": "WarmupDecayLR",
+        "params": {
+            "warmup_min_lr": "auto",
+            "warmup_max_lr": "auto",
+            "warmup_num_steps": "auto",
+            "total_num_steps": "auto"
+        }
+    },
+
+    "zero_optimization": {
+        "stage": 2,
+        "allgather_partitions": true,
+        "allgather_bucket_size": 3e8,
+        "overlap_comm": true,
+        "reduce_scatter": true,
+        "reduce_bucket_size": 3e8,
+        "contiguous_gradients": true,
+        "cpu_offload": true
+    },
+
+    "gradient_accumulation_steps": "auto",
+    "gradient_clipping": "auto",
+    "steps_per_print": 5000,
+    "train_batch_size": "auto",
+    "train_micro_batch_size_per_gpu": "auto",
+    "wall_clock_breakdown": false
+}

jz/configs/deepspeed/ds_zero3.json

@@ -0,0 +1,56 @@
+{
+    "fp16": {
+        "enabled": true,
+        "loss_scale": 0,
+        "loss_scale_window": 1000,
+        "initial_scale_power": 16,
+        "hysteresis": 2,
+        "min_loss_scale": 1
+    },
+
+    "optimizer": {
+        "type": "AdamW",
+        "params": {
+            "lr": "auto",
+            "betas": "auto",
+            "eps": "auto",
+            "weight_decay": "auto"
+        }
+    },
+
+    "scheduler": {
+        "type": "WarmupDecayLR",
+        "params": {
+            "warmup_min_lr": "auto",
+            "warmup_max_lr": "auto",
+            "warmup_num_steps": "auto",
+            "total_num_steps": "auto"
+        }
+    },
+    "zero_optimization": {
+        "stage": 3,
+        "offload_optimizer": {
+            "device": "cpu",
+            "pin_memory": true
+        },
+        "offload_param": {
+            "device": "cpu",
+            "pin_memory": true
+        },
+        "overlap_comm": true,
+        "contiguous_gradients": true,
+        "sub_group_size": 1e14,
+        "reduce_bucket_size": "auto",
+        "stage3_prefetch_bucket_size": "auto",
+        "stage3_param_persistence_threshold": "auto",
+        "stage3_max_live_parameters": 1e9,
+        "stage3_max_reuse_distance": 1e9,
+        "stage3_gather_fp16_weights_on_model_save": true
+    },
+    "gradient_accumulation_steps": "auto",
+    "gradient_clipping": "auto",
+    "steps_per_print": 5000,
+    "train_batch_size": "auto",
+    "train_micro_batch_size_per_gpu": "auto",
+    "wall_clock_breakdown": false
+}

jz/configs/lm_t5/lm_t5-large.json

@@ -0,0 +1,23 @@
+{
+    "architectures": [
+      "T5WithLMHeadModel"
+    ],
+    "d_ff": 5120,
+    "d_kv": 64,
+    "d_model": 1280,
+    "decoder_start_token_id": 0,
+    "dropout_rate": 0.1,
+    "eos_token_id": 1,
+    "initializer_factor": 1.0,
+    "is_encoder_decoder": true,
+    "layer_norm_epsilon": 1e-06,
+    "model_type": "t5",
+    "num_heads": 20,
+    "num_layers": 36,
+    "output_past": true,
+    "pad_token_id": 0,
+    "relative_attention_num_buckets": 64,
+    "task_specific_params": {
+    },
+    "vocab_size": 32128
+}

jz/configs/lm_t5/lm_t5-medium.json

@@ -0,0 +1,23 @@
+{
+    "architectures": [
+      "T5WithLMHeadModel"
+    ],
+    "d_ff": 4096,
+    "d_kv": 64,
+    "d_model": 1024,
+    "decoder_start_token_id": 0,
+    "dropout_rate": 0.1,
+    "eos_token_id": 1,
+    "initializer_factor": 1.0,
+    "is_encoder_decoder": true,
+    "layer_norm_epsilon": 1e-06,
+    "model_type": "t5",
+    "num_heads": 16,
+    "num_layers": 24,
+    "output_past": true,
+    "pad_token_id": 0,
+    "relative_attention_num_buckets": 64,
+    "task_specific_params": {
+    },
+    "vocab_size": 32128
+}

jz/configs/lm_t5/lm_t5-small.json

@@ -0,0 +1,23 @@
+{
+    "architectures": [
+      "T5WithLMHeadModel"
+    ],
+    "d_ff": 3072,
+    "d_kv": 64,
+    "d_model": 768,
+    "decoder_start_token_id": 0,
+    "dropout_rate": 0.1,
+    "eos_token_id": 1,
+    "initializer_factor": 1.0,
+    "is_encoder_decoder": true,
+    "layer_norm_epsilon": 1e-06,
+    "model_type": "t5",
+    "num_heads": 12,
+    "num_layers": 12,
+    "output_past": true,
+    "pad_token_id": 0,
+    "relative_attention_num_buckets": 64,
+    "task_specific_params": {
+    },
+    "vocab_size": 32128
+}

jz/configs/lm_t5/lm_t5-tiny.json

@@ -0,0 +1,23 @@
+{
+    "architectures": [
+      "T5WithLMHeadModel"
+    ],
+    "d_ff": 2048,
+    "d_kv": 64,
+    "d_model": 512,
+    "decoder_start_token_id": 0,
+    "dropout_rate": 0.1,
+    "eos_token_id": 1,
+    "initializer_factor": 1.0,
+    "is_encoder_decoder": true,
+    "layer_norm_epsilon": 1e-06,
+    "model_type": "t5",
+    "num_heads": 8,
+    "num_layers": 6,
+    "output_past": true,
+    "pad_token_id": 0,
+    "relative_attention_num_buckets": 64,
+    "task_specific_params": {
+    },
+    "vocab_size": 32128
+}

jz/configs/lm_t5/lm_t5-xl.json

@@ -0,0 +1,23 @@
+{
+    "architectures": [
+      "T5WithLMHeadModel"
+    ],
+    "d_ff": 6400,
+    "d_kv": 64,
+    "d_model": 1600,
+    "decoder_start_token_id": 0,
+    "dropout_rate": 0.1,
+    "eos_token_id": 1,
+    "initializer_factor": 1.0,
+    "is_encoder_decoder": true,
+    "layer_norm_epsilon": 1e-06,
+    "model_type": "t5",
+    "num_heads": 25,
+    "num_layers": 48,
+    "output_past": true,
+    "pad_token_id": 0,
+    "relative_attention_num_buckets": 64,
+    "task_specific_params": {
+    },
+    "vocab_size": 32128
+}

jz/crontab/README.md

@@ -0,0 +1,84 @@
+# Crontab Jobs
+
+JZ has no crontab so we have to emulate it.
+
+Put your slurm scripts into either:
+```
+$six_ALL_CCFRWORK/cron/cron.hourly
+$six_ALL_CCFRWORK/cron/cron.daily
+```
+depending on whether you want to run those approximately once an hour or once a day.
+
+Any scripts found in these dirs that have `.slurm` extension, will be run as `sbatch scriptname`.
+
+## The scheduler
+
+The scheduler isn't run automatically, we have to launch it and make sure it gets restarted manually if SLURM
+is restarted (not sure if jobs get preserved or not):
+
+* [cron-hourly.slurm](./cron-hourly.slurm)
+* [cron-daily.slurm](./cron-daily.slurm)
+
+If these 2 aren't running when you run:
+
+```
+squeue --user=$(getent group six | cut -d: -f4) | grep cron
+```
+the re-launch the missing one(s) with:
+```
+cd $six_ALL_CCFRWORK/cron/scheduler
+sbatch cron-hourly.slurm
+sbatch cron-daily.slurm
+```
+
+If these scripts aren't there, copy them from the folder in the repo where this README.md is located.
+
+XXX: need some kind of a watchdog to ensure the 2 cron scheduler jobs don't disappear.
+
+quick alias to test:
+```
+alias cron-check="squeue --user=$(getent group six | cut -d: -f4) | grep cron"
+```
+
+## Example daily entry
+
+Here is an example of a job that gets to run daily.
+```
+$ cat $six_ALL_CCFRWORK/cron/cron.daily/mlocate-update.slurm
+#!/bin/bash
+#SBATCH --job-name=mlocate-update    # job name
+#SBATCH --ntasks=1                   # number of MP tasks
+#SBATCH --nodes=1
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --time=1:00:00               # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --partition=compil
+#SBATCH --account=six@cpu
+
+set -e
+date
+echo "updating mlocate db"
+# "--require-visibility 0" is required when launching this command as a regular user
+/usr/bin/updatedb -o $ALL_CCFRWORK/lib/mlocate/work.db   -U $ALL_CCFRWORK --require-visibility 0
+/usr/bin/updatedb -o $ALL_CCFRWORK/lib/mlocate/worksf.db -U /gpfsssd/worksf/projects/rech/six/commun --require-visibility 0
+```
+
+This builds an index of the files under WORK which you can then quickly query with:
+```
+/usr/bin/locate -d /gpfswork/rech/six/commun/lib/mlocate/mlocate.db pattern
+```
+
+The slurm script `mlocate-update.slurm` has been placed inside `$six_ALL_CCFRWORK/cron/cron.daily`. To stop running it, just move it elsewhere.
+
+Another approach to adding/removing is to keep the slurm scripts elsewhere and symlink to them from either
+`$six_ALL_CCFRWORK/cron/cron.daily` or `$six_ALL_CCFRWORK/cron/cron.hourly` according to the need.
+
+
+## Permissions
+
+The scheduler runs with Unix permissions of the person who launched the SLRUM cron scheduler job and so all other SLURM scripts launched by that cron job.
+
+
+## TODO
+
+XXX: need to have a facility to report failures. Which is tricky because the job has to run on a SLURM partition that has Internet and that's just `--partition=prepost` and `--partition=compil`

jz/crontab/cron-daily.slurm

@@ -0,0 +1,23 @@
+#!/bin/bash
+#SBATCH --job-name=cron-daily        # job name
+#SBATCH --ntasks=1                   # number of MP tasks
+#SBATCH --nodes=1
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --time=2:00:00               # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --partition=compil
+#SBATCH --account=six@cpu
+
+# do not set -e - we must run all of it
+# set -x -e
+
+cd $six_ALL_CCFRWORK/cron/scheduler
+
+# ensure to restart self first
+sbatch --begin=now+24hour cron-daily.slurm
+
+# now launch any slurm scripts in cron.daily
+cd $six_ALL_CCFRWORK/cron/cron.daily
+for f in *.slurm; do
+  sbatch "$f"
+done

jz/crontab/cron-hourly.slurm

@@ -0,0 +1,23 @@
+#!/bin/bash
+#SBATCH --job-name=cron-hourly       # job name
+#SBATCH --ntasks=1                   # number of MP tasks
+#SBATCH --nodes=1
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --time=0:30:00               # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --partition=compil
+#SBATCH --account=six@cpu
+
+# do not set -e - we must run all of it
+# set -x -e
+
+cd $six_ALL_CCFRWORK/cron/scheduler
+
+# ensure to restart self first
+sbatch --begin=now+1hour cron-hourly.slurm
+
+# now launch any slurm scripts in cron.hourly
+cd $six_ALL_CCFRWORK/cron/cron.hourly
+for f in *.slurm; do
+  sbatch "$f"
+done

jz/envs/start-prod

@@ -0,0 +1,60 @@
+# This is a python production script for JZ
+#
+# Activate with:
+#
+# source ./start-prod
+#
+#
+
+# if this session isn't run via a login shell, which is the case when running a
+# command which is not shell via ssh, the bash function `module` will be missing.
+# so work around it by emulating part of the login shell that loads modules environment
+# if [ -z $(type -t module) ]
+# then
+#    . /etc/profile.d/z_modules.sh
+# fi
+module purge
+module load pytorch-gpu/py3/1.8.1
+module load nvtop git git-lfs github-cli mc
+
+# git prompt
+export GIT_PROMPT_ONLY_IN_REPO=0;
+export GIT_PROMPT_THEME="JZPRod"
+source $six_ALL_CCFRWORK/envs/.bash-git-prompt/gitprompt.sh
+
+# We are using common disk spaces for datasets, caches, and experiment dumps:
+#
+#- Code, cache and datasets -> `$six_ALL_CCFRWORK/cache_dir` and ``$six_ALL_CCFRWORK/datasets`
+#- Experiment dumps -> `$six_ALL_CCFRWORK/experiments`
+
+# specific caches
+
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+
+#export PYTHONPATH=$WORK/hf/transformers-master/src
+
+export DATASETS_CUSTOM=$six_ALL_CCFRWORK/datasets-custom
+
+### CONDA ###
+
+# >>> conda initialize >>>
+# !! Contents within this block are managed by 'conda init' !!
+__conda_setup="$('/gpfslocalsup/pub/anaconda-py3/2020.02/bin/conda' 'shell.bash' 'hook' 2> /dev/null)"
+if [ $? -eq 0 ]; then
+    eval "$__conda_setup"
+else
+    if [ -f "/gpfslocalsup/pub/anaconda-py3/2020.02/etc/profile.d/conda.sh" ]; then
+        . "/gpfslocalsup/pub/anaconda-py3/2020.02/etc/profile.d/conda.sh"
+    else
+        export PATH="/gpfslocalsup/pub/anaconda-py3/2020.02/bin:$PATH"
+    fi
+fi
+unset __conda_setup
+# <<< conda initialize <<<
+
+export CONDA_ENVS_PATH=$six_ALL_CCFRWORK/conda
+conda activate base
+conda activate hf-prod

jz/envs/start-user

@@ -0,0 +1,59 @@
+# user env start script
+
+# replace stas with the name of your conda env in this script
+
+# if this session isn't run via a login shell, which is the case when running a
+# command which is not shell via ssh, the bash function `module` will be missing.
+# so work around it by emulating part of the login shell that loads modules environment
+#if [ -z $(type -t module) ]
+#then
+#   . /etc/profile.d/z_modules.sh
+#fi
+module purge
+module load pytorch-gpu/py3/1.8.1
+module load nvtop git git-lfs github-cli mc
+
+# git prompt
+export GIT_PROMPT_ONLY_IN_REPO=0;
+export GIT_PROMPT_THEME="JZPRod"
+source $six_ALL_CCFRWORK/envs/.bash-git-prompt/gitprompt.sh
+
+# We are using common disk spaces for datasets, caches, and experiment dumps:
+#
+#- Code, cache and datasets -> `$six_ALL_CCFRWORK/cache_dir` and ``$ALL_CCFRWORK/datasets`
+#- Experiment dumps -> `$six_ALL_CCFRWORK/EXPERIMENTS`
+
+# specific caches
+
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+
+#export PYTHONPATH=$WORK/hf/transformers-master/src
+
+export DATASETS_CUSTOM=$six_ALL_CCFRWORK/datasets-custom
+
+
+
+
+### CONDA ###
+
+# >>> conda initialize >>>
+# !! Contents within this block are managed by 'conda init' !!
+__conda_setup="$('/gpfslocalsup/pub/anaconda-py3/2020.02/bin/conda' 'shell.bash' 'hook' 2> /dev/null)"
+if [ $? -eq 0 ]; then
+    eval "$__conda_setup"
+else
+    if [ -f "/gpfslocalsup/pub/anaconda-py3/2020.02/etc/profile.d/conda.sh" ]; then
+        . "/gpfslocalsup/pub/anaconda-py3/2020.02/etc/profile.d/conda.sh"
+    else
+        export PATH="/gpfslocalsup/pub/anaconda-py3/2020.02/bin:$PATH"
+    fi
+fi
+unset __conda_setup
+# <<< conda initialize <<<
+
+export CONDA_ENVS_PATH=$six_ALL_CCFRWORK/conda
+conda activate base
+conda activate stas

jz/envs/workarounds.md

@@ -0,0 +1,8 @@
+# Workarounds
+
+## Missing certificates
+
+Sometimes, some certificates can be missing. It's possible to point to our own local versions of the certificates. You can simply copy them to `$six_ALL_CCFRWORK/etc/ssl/certs/` or any other relevant folder:
+```bash
+export CURL_CA_BUNDLE=$six_ALL_CCFRWORK/etc/ssl/certs/ca-certificates.crt
+```

jz/model_storage/move_checkpoints_to_store_tr11b.slurm

@@ -0,0 +1,44 @@
+#!/bin/bash
+#SBATCH --job-name=tr11b_move_to_tar # job name
+#SBATCH --ntasks=1                   # number of MP tasks
+#SBATCH --nodes=1
+#SBATCH --cpus-per-task=4           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --time=20:00:00             # maximum execution time (HH:MM:SS)
+#SBATCH --output=logs/%x-%j.out          # output file name
+#SBATCH --account=six@cpu
+#SBATCH --array=0-1362%1
+#SBATCH --partition=cpu_p1
+
+# DEBUG
+# SLURM_ARRAY_TASK_ID=0 # 0-6549
+
+pushd $six_ALL_CCFRWORK/checkpoints
+# readarray CHECKPOINTS < <(find . -regex '\./tr11[a-z].*/global_step[0-9]*')
+# DEBUG regex to test out only on tr11e-350
+# readarray CHECKPOINTS < <(find . -regex '\./tr11e-350M-ml/.*/global_step[0-9]*')
+# batch size 512 -> one out of 4 checkpoints for 1B tokens
+readarray CHECKPOINTS < <(find . -regex '\./tr11b-1B3-ml/.*/global_step[0-9]*000')
+
+echo "Total number of checkpoints to tar: ${#CHECKPOINTS[@]}"
+
+CHECKPOINT_TO_TAR=${CHECKPOINTS[$SLURM_ARRAY_TASK_ID]}
+echo "Checkpoint to tar: $CHECKPOINT_TO_TAR"
+
+TEMPNAME=$(dirname $CHECKPOINT_TO_TAR)
+DIRNAME=${TEMPNAME:2}
+BASENAME=$(basename $CHECKPOINT_TO_TAR)
+
+CHECKPOINT_TO_TAR=$DIRNAME/$BASENAME
+CHECKPOINT_TAR_TO_FOLDER=$six_ALL_CCFRSTORE/checkpoints/$DIRNAME
+CHECKPOINT_TAR_TO=$CHECKPOINT_TAR_TO_FOLDER/$BASENAME.tar
+
+mkdir -p $CHECKPOINT_TAR_TO_FOLDER
+echo $CHECKPOINT_TO_TAR
+echo $CHECKPOINT_TAR_TO_FOLDER
+
+# cvfj for bz2 compression; won't change much
+tar cvf $CHECKPOINT_TAR_TO $CHECKPOINT_TO_TAR
+
+popd
+

jz/model_storage/move_checkpoints_to_store_tr11e.slurm

@@ -0,0 +1,43 @@
+#!/bin/bash
+#SBATCH --job-name=move_to_tar # job name
+#SBATCH --ntasks=1                   # number of MP tasks
+#SBATCH --nodes=1
+#SBATCH --cpus-per-task=4           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --time=20:00:00             # maximum execution time (HH:MM:SS)
+#SBATCH --output=logs/%x-%j.out          # output file name
+#SBATCH --account=six@cpu
+#SBATCH --array=0-276%1
+#SBATCH --partition=cpu_p1
+
+# DEBUG
+# SLURM_ARRAY_TASK_ID=0 # 0-6549
+
+pushd $six_ALL_CCFRWORK/checkpoints
+# readarray CHECKPOINTS < <(find . -regex '\./tr11[a-z].*/global_step[0-9]*')
+# DEBUG regex to test out only on tr11e-350
+# readarray CHECKPOINTS < <(find . -regex '\./tr11e-350M-ml/.*/global_step[0-9]*')
+# batch size 256 -> one out of 8 checkpoints for 1B tokens
+readarray CHECKPOINTS < <(find . -regex '\./tr11e-350M-ml/.*/global_step[0-9]*[02468]000')
+
+echo "Total number of checkpoints to tar: ${#CHECKPOINTS[@]}"
+
+CHECKPOINT_TO_TAR=${CHECKPOINTS[$SLURM_ARRAY_TASK_ID]}
+echo "Checkpoint to tar: $CHECKPOINT_TO_TAR"
+
+TEMPNAME=$(dirname $CHECKPOINT_TO_TAR)
+DIRNAME=${TEMPNAME:2}
+BASENAME=$(basename $CHECKPOINT_TO_TAR)
+
+CHECKPOINT_TO_TAR=$DIRNAME/$BASENAME
+CHECKPOINT_TAR_TO_FOLDER=$six_ALL_CCFRSTORE/checkpoints/$DIRNAME
+CHECKPOINT_TAR_TO=$CHECKPOINT_TAR_TO_FOLDER/$BASENAME.tar
+
+mkdir -p $CHECKPOINT_TAR_TO_FOLDER
+echo $CHECKPOINT_TO_TAR
+echo $CHECKPOINT_TAR_TO
+
+# cvfj for bz2 compression; won't change much
+tar cvf $CHECKPOINT_TAR_TO $CHECKPOINT_TO_TAR
+
+popd

jz/model_storage/move_checkpoints_to_store_tr11f.slurm

@@ -0,0 +1,44 @@
+#!/bin/bash
+#SBATCH --job-name=tr11f_move_to_tar # job name
+#SBATCH --ntasks=1                   # number of MP tasks
+#SBATCH --nodes=1
+#SBATCH --cpus-per-task=4           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --time=20:00:00             # maximum execution time (HH:MM:SS)
+#SBATCH --output=logs/%x-%j.out          # output file name
+#SBATCH --account=six@cpu
+#SBATCH --array=0-155%1
+#SBATCH --partition=cpu_p1
+
+# DEBUG
+# SLURM_ARRAY_TASK_ID=0 # 0-6549
+
+pushd $six_ALL_CCFRWORK/checkpoints
+# readarray CHECKPOINTS < <(find . -regex '\./tr11[a-z].*/global_step[0-9]*')
+# DEBUG regex to test out only on tr11e-350
+# readarray CHECKPOINTS < <(find . -regex '\./tr11e-350M-ml/.*/global_step[0-9]*')
+# batch size 512 -> one out of 4 checkpoints for 1B tokens
+readarray CHECKPOINTS < <(find . -regex '\./tr11f-6B3-ml/.*/global_step[0-9]*000')
+
+echo "Total number of checkpoints to tar: ${#CHECKPOINTS[@]}"
+
+CHECKPOINT_TO_TAR=${CHECKPOINTS[$SLURM_ARRAY_TASK_ID]}
+echo "Checkpoint to tar: $CHECKPOINT_TO_TAR"
+
+TEMPNAME=$(dirname $CHECKPOINT_TO_TAR)
+DIRNAME=${TEMPNAME:2}
+BASENAME=$(basename $CHECKPOINT_TO_TAR)
+
+CHECKPOINT_TO_TAR=$DIRNAME/$BASENAME
+CHECKPOINT_TAR_TO_FOLDER=$six_ALL_CCFRSTORE/checkpoints/$DIRNAME
+CHECKPOINT_TAR_TO=$CHECKPOINT_TAR_TO_FOLDER/$BASENAME.tar
+
+mkdir -p $CHECKPOINT_TAR_TO_FOLDER
+echo $CHECKPOINT_TO_TAR
+echo $CHECKPOINT_TAR_TO
+
+# cvfj for bz2 compression; won't change much
+tar cvf $CHECKPOINT_TAR_TO $CHECKPOINT_TO_TAR
+
+popd
+

jz/scripts/custom_callbacks.py

@@ -0,0 +1,95 @@
+import os
+
+from transformers import TrainerCallback, is_tensorboard_available
+from transformers.integrations import rewrite_logs
+
+
+class LogFlosCallback(TrainerCallback):
+    """
+    A :class:`~transformers.TrainerCallback` that adds current flos to every log.
+    """
+
+    def on_log(self, args, state, control, logs=None, **kwargs):
+        logs["total_flos"] = state.total_flos
+
+
+class TensorBoardFloIndexedCallback(TrainerCallback):
+    """
+    A :class:`~transformers.TrainerCallback` that sends the logs to `TensorBoard
+    <https://www.tensorflow.org/tensorboard>`__.
+
+    Args:
+        tb_writer (:obj:`SummaryWriter`, `optional`):
+            The writer to use. Will instantiate one if not set.
+    """
+
+    def __init__(self, tb_writer=None):
+        has_tensorboard = is_tensorboard_available()
+        assert (
+            has_tensorboard
+        ), "TensorBoardCallback requires tensorboard to be installed. Either update your PyTorch version or install tensorboardX."
+        if has_tensorboard:
+            try:
+                from torch.utils.tensorboard import SummaryWriter  # noqa: F401
+
+                self._SummaryWriter = SummaryWriter
+            except ImportError:
+                try:
+                    from tensorboardX import SummaryWriter
+
+                    self._SummaryWriter = SummaryWriter
+                except ImportError:
+                    self._SummaryWriter = None
+        else:
+            self._SummaryWriter = None
+        self.tb_writer = tb_writer
+
+    def _init_summary_writer(self, args, log_dir=None):
+        log_dir = log_dir or args.logging_dir
+        if self._SummaryWriter is not None:
+            self.tb_writer = self._SummaryWriter(log_dir=log_dir)
+
+    def on_train_begin(self, args, state, control, **kwargs):
+        if not state.is_world_process_zero:
+            return
+
+        log_dir = None
+
+        if state.is_hyper_param_search:
+            trial_name = state.trial_name
+            if trial_name is not None:
+                log_dir = os.path.join(args.logging_dir, trial_name)
+
+        self._init_summary_writer(args, log_dir)
+
+        if self.tb_writer is not None:
+            self.tb_writer.add_text("args", args.to_json_string())
+            if "model" in kwargs:
+                model = kwargs["model"]
+                if hasattr(model, "config") and model.config is not None:
+                    model_config_json = model.config.to_json_string()
+                    self.tb_writer.add_text("model_config", model_config_json)
+            # Version of TensorBoard coming from tensorboardX does not have this method.
+            if hasattr(self.tb_writer, "add_hparams"):
+                self.tb_writer.add_hparams(args.to_sanitized_dict(), metric_dict={})
+
+    def on_log(self, args, state, control, logs=None, **kwargs):
+        if not state.is_world_process_zero:
+            return
+
+        if self.tb_writer is None:
+            self._init_summary_writer(args)
+
+        if self.tb_writer is not None:
+            logs = rewrite_logs(logs)
+            self.tb_writer.add_scalar("Conversion/x steps - y flos", state.total_flos, state.global_step)
+            self.tb_writer.add_scalar("Conversion/x flos - y steps", state.global_step, state.total_flos)
+            for k, v in logs.items():
+                if isinstance(v, (int, float)):
+                    self.tb_writer.add_scalar(f"Flos/{k}", v, state.total_flos)
+                    self.tb_writer.add_scalar(f"Steps/{k}", v, state.global_step)
+            self.tb_writer.flush()
+
+    def on_train_end(self, args, state, control, **kwargs):
+        if self.tb_writer:
+            self.tb_writer.close()

jz/scripts/run_clm.py

@@ -0,0 +1,520 @@
+#!/usr/bin/env python
+# coding=utf-8
+# Copyright 2020 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Fine-tuning the library models for causal language modeling (GPT, GPT-2, CTRL, ...) on a text file or a dataset.
+
+Here is the full list of checkpoints on the hub that can be fine-tuned by this script:
+https://huggingface.co/models?filter=causal-lm
+"""
+# You can also adapt this script on your own causal language modeling task. Pointers for this are left as comments.
+
+import logging
+import math
+import os
+import sys
+from dataclasses import dataclass, field
+from typing import Optional
+
+import torch.distributed
+from datasets import load_dataset
+
+import transformers
+from transformers import (
+    CONFIG_MAPPING,
+    MODEL_FOR_CAUSAL_LM_MAPPING,
+    AutoConfig,
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    HfArgumentParser,
+    Trainer,
+    TrainingArguments,
+    default_data_collator,
+    set_seed,
+)
+from transformers.testing_utils import CaptureLogger
+from transformers.trainer_utils import get_last_checkpoint, is_main_process
+from transformers.utils import check_min_version
+
+### I very much dislike this solution. `run_clm.py` should probably be at the root, or install as an editable package.
+import os
+currentdir = os.path.dirname(os.path.realpath(__file__))
+parentdir = os.path.dirname(currentdir)
+sys.path.append(parentdir)
+###
+
+from models.decoder_only_t5 import DecoderOnlyT5Config, DecoderOnlyT5LMHeadModel
+
+CONFIG_MAPPING["decoder_only_t5"] = DecoderOnlyT5Config
+MODEL_FOR_CAUSAL_LM_MAPPING[DecoderOnlyT5Config] = DecoderOnlyT5LMHeadModel
+
+# Will error if the minimal version of Transformers is not installed. Remove at your own risks.
+from custom_callbacks import LogFlosCallback, TensorBoardFloIndexedCallback
+
+check_min_version("4.6.0.dev0")
+
+logging.basicConfig(
+    format="%(asctime)s - %(levelname)s - %(process)d - %(name)s - %(message)s",
+    datefmt="%m/%d/%Y %H:%M:%S",
+    level=logging.INFO,
+)
+logger = logging.getLogger(__name__)
+
+
+MODEL_CONFIG_CLASSES = list(MODEL_FOR_CAUSAL_LM_MAPPING.keys())
+MODEL_TYPES = tuple(conf.model_type for conf in MODEL_CONFIG_CLASSES)
+
+
+@dataclass
+class ModelArguments:
+    """
+    Arguments pertaining to which model/config/tokenizer we are going to fine-tune, or train from scratch.
+    """
+
+    model_name_or_path: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "The model checkpoint for weights initialization."
+            "Don't set if you want to train a model from scratch."
+        },
+    )
+    model_type: Optional[str] = field(
+        default=None,
+        metadata={"help": "If training from scratch, pass a model type from the list: " + ", ".join(MODEL_TYPES)},
+    )
+    config_name: Optional[str] = field(
+        default=None, metadata={"help": "Pretrained config name or path if not the same as model_name"}
+    )
+    tokenizer_name: Optional[str] = field(
+        default=None, metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"}
+    )
+    cache_dir: Optional[str] = field(
+        default=None,
+        metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"},
+    )
+    use_fast_tokenizer: bool = field(
+        default=True,
+        metadata={"help": "Whether to use one of the fast tokenizer (backed by the tokenizers library) or not."},
+    )
+    model_revision: str = field(
+        default="main",
+        metadata={"help": "The specific model version to use (can be a branch name, tag name or commit id)."},
+    )
+    use_auth_token: bool = field(
+        default=False,
+        metadata={
+            "help": "Will use the token generated when running `huggingface-cli login` (necessary to use this script "
+            "with private models)."
+        },
+    )
+
+
+@dataclass
+class ConfigArguments:
+    """
+    Arguments defining the new model we're about to train when training from scratch
+    """
+
+    n_ctx: Optional[int] = field(default=1024, metadata={"help": "Dimensionality of the causal mask"})
+    n_embd: Optional[int] = field(
+        default=768, metadata={"help": "Dimensionality of the embeddings and hidden states."}
+    )
+    n_layer: Optional[int] = field(default=12, metadata={"help": "Number of hidden layers."})
+    n_head: Optional[int] = field(default=12, metadata={"help": "Number of attention heads for each attention layer."})
+    n_inner: Optional[int] = field(default=None, metadata={"help": "Dimensionality of the inner feed-forward layers."})
+
+
+@dataclass
+class DataTrainingArguments:
+    """
+    Arguments pertaining to what data we are going to input our model for training and eval.
+    """
+
+    sanity: bool = field(
+        default=False, metadata={"help": "Only use fraction of the dataset"}
+    )
+    dataset_name: Optional[str] = field(
+        default=None, metadata={"help": "The name of the dataset to use (via the datasets library)."}
+    )
+    dataset_config_name: Optional[str] = field(
+        default=None, metadata={"help": "The configuration name of the dataset to use (via the datasets library)."}
+    )
+    train_file: Optional[str] = field(default=None, metadata={"help": "The input training data file (a text file)."})
+    validation_file: Optional[str] = field(
+        default=None,
+        metadata={"help": "An optional input evaluation data file to evaluate the perplexity on (a text file)."},
+    )
+    max_train_samples: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": "For debugging purposes or quicker training, truncate the number of training examples to this "
+            "value if set."
+        },
+    )
+    max_val_samples: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": "For debugging purposes or quicker training, truncate the number of validation examples to this "
+            "value if set."
+        },
+    )
+
+    block_size: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": "Optional input sequence length after tokenization. "
+            "The training dataset will be truncated in block of this size for training. "
+            "Default to the model max input length for single sentence inputs (take into account special tokens)."
+        },
+    )
+    overwrite_cache: bool = field(
+        default=False, metadata={"help": "Overwrite the cached training and evaluation sets"}
+    )
+    validation_split_percentage: Optional[int] = field(
+        default=5,
+        metadata={
+            "help": "The percentage of the train set used as validation set in case there's no validation split"
+        },
+    )
+    preprocessing_num_workers: Optional[int] = field(
+        default=None,
+        metadata={"help": "The number of processes to use for the preprocessing."},
+    )
+
+    def __post_init__(self):
+        if self.dataset_name is None and self.train_file is None and self.validation_file is None:
+            raise ValueError("Need either a dataset name or a training/validation file.")
+        else:
+            if self.train_file is not None:
+                extension = self.train_file.split(".")[-1]
+                assert extension in ["csv", "json", "txt"], "`train_file` should be a csv, a json or a txt file."
+            if self.validation_file is not None:
+                extension = self.validation_file.split(".")[-1]
+                assert extension in ["csv", "json", "txt"], "`validation_file` should be a csv, a json or a txt file."
+
+
+def main():
+    # See all possible arguments in src/transformers/training_args.py
+    # or by passing the --help flag to this script.
+    # We now keep distinct sets of args, for a cleaner separation of concerns.
+
+    parser = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments, ConfigArguments))
+    if len(sys.argv) == 2 and sys.argv[1].endswith(".json"):
+        # If we pass only one argument to the script and it's the path to a json file,
+        # let's parse it to get our arguments.
+        model_args, data_args, training_args, config_args = parser.parse_json_file(
+            json_file=os.path.abspath(sys.argv[1])
+        )
+    else:
+        model_args, data_args, training_args, config_args = parser.parse_args_into_dataclasses()
+
+    # Detecting last checkpoint.
+    last_checkpoint = None
+    if os.path.isdir(training_args.output_dir) and training_args.do_train and not training_args.overwrite_output_dir:
+        last_checkpoint = get_last_checkpoint(training_args.output_dir)
+        if last_checkpoint is None and len(os.listdir(training_args.output_dir)) > 0:
+            raise ValueError(
+                f"Output directory ({training_args.output_dir}) already exists and is not empty. "
+                "Use --overwrite_output_dir to overcome."
+            )
+        elif last_checkpoint is not None:
+            logger.info(
+                f"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change "
+                "the `--output_dir` or add `--overwrite_output_dir` to train from scratch."
+            )
+
+    # Setup logging
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s -   %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        handlers=[logging.StreamHandler(sys.stdout)],
+    )
+    logger.setLevel(logging.INFO if is_main_process(training_args.local_rank) else logging.WARN)
+
+    # Log on each process the small summary:
+    logger.warning(
+        f"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}"
+        + f"distributed training: {bool(training_args.local_rank != -1)}, 16-bits training: {training_args.fp16}"
+    )
+    # Set the verbosity to info of the Transformers logger (on main process only):
+    if is_main_process(training_args.local_rank):
+        transformers.utils.logging.set_verbosity_info()
+        transformers.utils.logging.enable_default_handler()
+        transformers.utils.logging.enable_explicit_format()
+    logger.info(f"Training/evaluation parameters {training_args}")
+
+    # Set seed before initializing model.
+    set_seed(training_args.seed)
+
+    # Get the datasets: you can either provide your own CSV/JSON/TXT training and evaluation files (see below)
+    # or just provide the name of one of the public datasets available on the hub at https://huggingface.co/datasets/
+    # (the dataset will be downloaded automatically from the datasets Hub).
+    #
+    # For CSV/JSON files, this script will use the column called 'text' or the first column if no column called
+    # 'text' is found. You can easily tweak this behavior (see below).
+    #
+    # In distributed training, the load_dataset function guarantee that only one local process can concurrently
+    # download the dataset.
+    if data_args.dataset_name is not None:
+        # Downloading and loading a dataset from the hub.
+        datasets = load_dataset(data_args.dataset_name, data_args.dataset_config_name, keep_in_memory=False, cache_dir=model_args.cache_dir)
+        if "validation" not in datasets.keys():
+            datasets["validation"] = load_dataset(
+                data_args.dataset_name,
+                data_args.dataset_config_name,
+                split=f"train[:{data_args.validation_split_percentage}%]",
+                keep_in_memory=False,
+                cache_dir=model_args.cache_dir
+            )
+            datasets["train"] = load_dataset(
+                data_args.dataset_name,
+                data_args.dataset_config_name,
+                split=f"train[{data_args.validation_split_percentage}%:]",
+                keep_in_memory=False,
+                cache_dir=model_args.cache_dir
+            )
+    else:
+        data_files = {}
+        if data_args.train_file is not None:
+            data_files["train"] = data_args.train_file
+        if data_args.validation_file is not None:
+            data_files["validation"] = data_args.validation_file
+        extension = (
+            data_args.train_file.split(".")[-1]
+            if data_args.train_file is not None
+            else data_args.validation_file.split(".")[-1]
+        )
+        if extension == "txt":
+            extension = "text"
+        datasets = load_dataset(extension, data_files=data_files, keep_in_memory=False, cache_dir=model_args.cache_dir)
+    if data_args.sanity:
+        datasets["train"] = datasets["train"].shard(100, index=0, contiguous=True)
+    # See more about loading any type of standard or custom dataset (from files, python dict, pandas DataFrame, etc) at
+    # https://huggingface.co/docs/datasets/loading_datasets.html.
+
+    # Load pretrained model and tokenizer
+    #
+    # Distributed training:
+    # The .from_pretrained methods guarantee that only one local process can concurrently
+    # download model & vocab.
+
+    config_kwargs = {
+        "cache_dir": model_args.cache_dir,
+        "revision": model_args.model_revision,
+        "use_auth_token": True if model_args.use_auth_token else None,
+    }
+    if model_args.config_name:
+        config = AutoConfig.from_pretrained(model_args.config_name, **config_kwargs)
+    elif model_args.model_name_or_path:
+        config = AutoConfig.from_pretrained(model_args.model_name_or_path, **config_kwargs)
+    else:
+        config = CONFIG_MAPPING[model_args.model_type](**vars(config_args), **config_kwargs)
+        logger.warning("You are instantiating a new config instance from scratch.")
+
+    tokenizer_kwargs = {
+        "cache_dir": model_args.cache_dir,
+        "use_fast": model_args.use_fast_tokenizer,
+        "revision": model_args.model_revision,
+        "use_auth_token": True if model_args.use_auth_token else None,
+    }
+    if model_args.tokenizer_name:
+        tokenizer = AutoTokenizer.from_pretrained(model_args.tokenizer_name, **tokenizer_kwargs)
+    elif model_args.model_name_or_path:
+        tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path, **tokenizer_kwargs)
+    else:
+        raise ValueError(
+            "You are instantiating a new tokenizer from scratch. This is not supported by this script."
+            "You can do it from another script, save it, and load it from here, using --tokenizer_name."
+        )
+
+    if model_args.model_name_or_path:
+        model = AutoModelForCausalLM.from_pretrained(
+            model_args.model_name_or_path,
+            from_tf=bool(".ckpt" in model_args.model_name_or_path),
+            config=config,
+            cache_dir=model_args.cache_dir,
+            revision=model_args.model_revision,
+            use_auth_token=True if model_args.use_auth_token else None,
+        )
+    else:
+        logger.info("Training new model from scratch")
+        model = AutoModelForCausalLM.from_config(config)
+
+    model.resize_token_embeddings(len(tokenizer))
+
+    # Preprocessing the datasets.
+    # First we tokenize all the texts.
+    if training_args.do_train:
+        column_names = datasets["train"].column_names
+    else:
+        column_names = datasets["validation"].column_names
+    text_column_name = "text" if "text" in column_names else column_names[0]
+
+    # since this will be pickled to avoid _LazyModule error in Hasher force logger loading before tokenize_function
+    tok_logger = transformers.utils.logging.get_logger("transformers.tokenization_utils_base")
+
+    datasets = datasets.shuffle()
+    def tokenize_function(examples):
+        with CaptureLogger(tok_logger) as cl:
+            output = tokenizer(examples[text_column_name])
+        # clm input could be much much longer than block_size
+        if "Token indices sequence length is longer than the" in cl.out:
+            tok_logger.warning(
+                "^^^^^^^^^^^^^^^^ Please ignore the warning above - this long input will be chunked into smaller bits before being passed to the model."
+            )
+        return output
+
+    # Ensures only the main process does dataset pre-processing; the other ones will load the `map` cache
+    if not is_main_process(training_args.local_rank):
+        print("waiting for main process to execute mapping")
+        torch.distributed.barrier()
+
+    logger.info("Mapping dataset to tokenized dataset.",)
+    tokenized_datasets = datasets.map(
+        tokenize_function,
+        batched=True,
+        num_proc=data_args.preprocessing_num_workers,
+        remove_columns=column_names,
+        load_from_cache_file=not data_args.overwrite_cache,
+        keep_in_memory=False
+    )
+
+    if data_args.block_size is None:
+        block_size = tokenizer.model_max_length
+        if block_size > 1024:
+            logger.warning(
+                f"The tokenizer picked seems to have a very large `model_max_length` ({tokenizer.model_max_length}). "
+                "Picking 1024 instead. You can change that default value by passing --block_size xxx."
+            )
+            block_size = 1024
+    else:
+        if data_args.block_size > tokenizer.model_max_length:
+            logger.warning(
+                f"The block_size passed ({data_args.block_size}) is larger than the maximum length for the model"
+                f"({tokenizer.model_max_length}). Using block_size={tokenizer.model_max_length}."
+            )
+        # block_size = min(data_args.block_size, tokenizer.model_max_length)
+        block_size = data_args.block_size
+
+    # Main data processing function that will concatenate all texts from our dataset and generate chunks of block_size.
+    def group_texts(examples):
+        # Concatenate all texts.
+        concatenated_examples = {k: sum(examples[k], []) for k in examples.keys()}
+        total_length = len(concatenated_examples[list(examples.keys())[0]])
+        # We drop the small remainder, we could add padding if the model supported it instead of this drop, you can
+        # customize this part to your needs.
+        total_length = (total_length // block_size) * block_size
+        # Split by chunks of max_len.
+        result = {
+            k: [t[i : i + block_size] for i in range(0, total_length, block_size)]
+            for k, t in concatenated_examples.items()
+        }
+        result["labels"] = result["input_ids"].copy()
+        return result
+
+    # Note that with `batched=True`, this map processes 1,000 texts together, so group_texts throws away a remainder
+    # for each of those groups of 1,000 texts. You can adjust that batch_size here but a higher value might be slower
+    # to preprocess.
+    #
+    # To speed up this part, we use multiprocessing. See the documentation of the map method for more information:
+    # https://huggingface.co/docs/datasets/package_reference/main_classes.html#datasets.Dataset.map
+
+    logger.info("Chunking tokenized dataset.")
+    lm_datasets = tokenized_datasets.map(
+        group_texts,
+        batched=True,
+        num_proc=data_args.preprocessing_num_workers,
+        load_from_cache_file=not data_args.overwrite_cache,
+        keep_in_memory=False
+    )
+
+    # Now the other ones can catch up.
+    if training_args.local_rank != -1 and is_main_process(training_args.local_rank):
+        print("loading results from main process")
+        torch.distributed.barrier()
+
+    if training_args.do_train:
+        if "train" not in tokenized_datasets:
+            raise ValueError("--do_train requires a train dataset")
+        train_dataset = lm_datasets["train"]
+        if data_args.max_train_samples is not None:
+            train_dataset = train_dataset.select(range(data_args.max_train_samples))
+
+    if training_args.do_eval:
+        if "validation" not in tokenized_datasets:
+            cutoff = data_args.validation_split_percentage * len(lm_datasets["train"]) // 100
+            train_dataset = lm_datasets["train"].select(range(cutoff, len(lm_datasets["train"])))
+            eval_dataset = lm_datasets["train"].select(range(cutoff))
+        else:
+            eval_dataset = lm_datasets["validation"]
+        if data_args.max_val_samples is not None:
+            eval_dataset = eval_dataset.select(range(data_args.max_val_samples))
+
+
+    # Initialize our Trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_dataset if training_args.do_train else None,
+        eval_dataset=eval_dataset if training_args.do_eval else None,
+        tokenizer=tokenizer,
+        # Data collator will default to DataCollatorWithPadding, so we change it.
+        data_collator=default_data_collator,
+        callbacks=[LogFlosCallback, TensorBoardFloIndexedCallback]
+    )
+
+    # Training
+    if training_args.do_train:
+        checkpoint = None
+        if training_args.resume_from_checkpoint is not None:
+            checkpoint = training_args.resume_from_checkpoint
+        elif last_checkpoint is not None:
+            checkpoint = last_checkpoint
+
+        train_result = trainer.train(resume_from_checkpoint=checkpoint)
+        trainer.save_model()  # Saves the tokenizer too for easy upload
+
+        metrics = train_result.metrics
+
+        max_train_samples = (
+            data_args.max_train_samples if data_args.max_train_samples is not None else len(train_dataset)
+        )
+        metrics["train_samples"] = min(max_train_samples, len(train_dataset))
+
+        trainer.log_metrics("train", metrics)
+        trainer.save_metrics("train", metrics)
+        trainer.save_state()
+
+    # Evaluation
+    if training_args.do_eval:
+        logger.info("*** Evaluate ***")
+
+        metrics = trainer.evaluate()
+
+        metrics["eval_samples"] = len(eval_dataset)
+        perplexity = math.exp(metrics["eval_loss"])
+        metrics["perplexity"] = perplexity
+
+        trainer.log_metrics("eval", metrics)
+        trainer.save_metrics("eval", metrics)
+
+
+def _mp_fn(index):
+    # For xla_spawn (TPUs)
+    main()
+
+
+if __name__ == "__main__":
+    main()

jz/scripts/run_clm_prompted.py

@@ -0,0 +1,534 @@
+#!/usr/bin/env python
+# coding=utf-8
+# Copyright 2020 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Prompted version of run_clm.
+"""
+# You can also adapt this script on your own causal language modeling task. Pointers for this are left as comments.
+
+import logging
+import math
+import os
+import sys
+from dataclasses import dataclass, field
+import torch
+from typing import Optional, Dict, List, Union
+
+from datasets import load_dataset, load_from_disk
+
+import transformers
+from transformers import (
+    CONFIG_MAPPING,
+    MODEL_FOR_CAUSAL_LM_MAPPING,
+    AutoConfig,
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    HfArgumentParser,
+    Trainer,
+    TrainingArguments,
+    default_data_collator,
+    set_seed,
+)
+from transformers.testing_utils import CaptureLogger
+from transformers.trainer_utils import get_last_checkpoint, is_main_process
+from transformers.utils import check_min_version
+from transformers.file_utils import PaddingStrategy
+from transformers.tokenization_utils_base import PreTrainedTokenizerBase
+
+# Will error if the minimal version of Transformers is not installed. Remove at your own risks.
+check_min_version("4.6.0.dev0")
+
+logging.basicConfig(
+    format="%(asctime)s - %(levelname)s - %(process)d - %(name)s - %(message)s",
+    datefmt="%m/%d/%Y %H:%M:%S",
+    level=logging.INFO,
+)
+logger = logging.getLogger(__name__)
+
+
+MODEL_CONFIG_CLASSES = list(MODEL_FOR_CAUSAL_LM_MAPPING.keys())
+MODEL_TYPES = tuple(conf.model_type for conf in MODEL_CONFIG_CLASSES)
+
+@dataclass
+class MyDataCollatorWithPadding:
+    """
+    Custom version of `DataCollatorWithPadding`.
+    """
+
+    tokenizer: PreTrainedTokenizerBase
+    padding: Union[bool, str, PaddingStrategy] = True
+    max_length: Optional[int] = None
+    pad_to_multiple_of: Optional[int] = None
+
+    def __call__(self, features: List[Dict[str, Union[List[int], torch.Tensor]]]) -> Dict[str, torch.Tensor]:
+        batch = self.tokenizer.pad(
+            features,
+            padding=self.padding,
+            max_length=self.max_length,
+            pad_to_multiple_of=self.pad_to_multiple_of,
+        )
+        if "label" in batch:
+            batch["labels"] = batch["label"]
+            del batch["label"]
+        if "label_ids" in batch:
+            batch["labels"] = batch["label_ids"]
+            del batch["label_ids"]
+        # Padding labels
+        max_l = len(batch["input_ids"][0])
+        result = []
+        for i in batch["labels"]:
+            result.append(i + [-100]*(max_l - len(i)))
+        batch["labels"] = result
+        for k, v in batch.items():
+            batch[k] = torch.tensor(v)
+        return batch
+
+@dataclass
+class ModelArguments:
+    """
+    Arguments pertaining to which model/config/tokenizer we are going to fine-tune, or train from scratch.
+    """
+
+    model_name_or_path: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "The model checkpoint for weights initialization."
+            "Don't set if you want to train a model from scratch."
+        },
+    )
+    model_type: Optional[str] = field(
+        default=None,
+        metadata={"help": "If training from scratch, pass a model type from the list: " + ", ".join(MODEL_TYPES)},
+    )
+    config_name: Optional[str] = field(
+        default=None, metadata={"help": "Pretrained config name or path if not the same as model_name"}
+    )
+    tokenizer_name: Optional[str] = field(
+        default=None, metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"}
+    )
+    cache_dir: Optional[str] = field(
+        default=None,
+        metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"},
+    )
+    use_fast_tokenizer: bool = field(
+        default=True,
+        metadata={"help": "Whether to use one of the fast tokenizer (backed by the tokenizers library) or not."},
+    )
+    model_revision: str = field(
+        default="main",
+        metadata={"help": "The specific model version to use (can be a branch name, tag name or commit id)."},
+    )
+    use_auth_token: bool = field(
+        default=False,
+        metadata={
+            "help": "Will use the token generated when running `huggingface-cli login` (necessary to use this script "
+            "with private models)."
+        },
+    )
+
+
+@dataclass
+class DataTrainingArguments:
+    """
+    Arguments pertaining to what data we are going to input our model for training and eval.
+    """
+
+    dataset_name: Optional[str] = field(
+        default=None, metadata={"help": "The name of the dataset to use (via the datasets library)."}
+    )
+    dataset_config_name: Optional[str] = field(
+        default=None, metadata={"help": "The configuration name of the dataset to use (via the datasets library)."}
+    )
+    train_file: Optional[str] = field(default=None, metadata={"help": "The input training data file (a text file)."})
+    validation_file: Optional[str] = field(
+        default=None,
+        metadata={"help": "An optional input evaluation data file to evaluate the perplexity on (a text file)."},
+    )
+    max_train_samples: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": "For debugging purposes or quicker training, truncate the number of training examples to this "
+            "value if set."
+        },
+    )
+    max_val_samples: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": "For debugging purposes or quicker training, truncate the number of validation examples to this "
+            "value if set."
+        },
+    )
+
+    block_size: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": "Optional input sequence length after tokenization. "
+            "The training dataset will be truncated in block of this size for training. "
+            "Default to the model max input length for single sentence inputs (take into account special tokens)."
+        },
+    )
+    overwrite_cache: bool = field(
+        default=False, metadata={"help": "Overwrite the cached training and evaluation sets"}
+    )
+    validation_split_percentage: Optional[int] = field(
+        default=5,
+        metadata={
+            "help": "The percentage of the train set used as validation set in case there's no validation split"
+        },
+    )
+    preprocessing_num_workers: Optional[int] = field(
+        default=None,
+        metadata={"help": "The number of processes to use for the preprocessing."},
+    )
+
+    def __post_init__(self):
+        if self.dataset_name is None and self.train_file is None and self.validation_file is None:
+            raise ValueError("Need either a dataset name or a training/validation file.")
+        else:
+            if self.train_file is not None:
+                extension = self.train_file.split(".")[-1]
+                assert extension in ["csv", "json", "txt"], "`train_file` should be a csv, a json or a txt file."
+            if self.validation_file is not None:
+                extension = self.validation_file.split(".")[-1]
+                assert extension in ["csv", "json", "txt"], "`validation_file` should be a csv, a json or a txt file."
+
+
+def main():
+    # See all possible arguments in src/transformers/training_args.py
+    # or by passing the --help flag to this script.
+    # We now keep distinct sets of args, for a cleaner separation of concerns.
+
+    parser = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments))
+    if len(sys.argv) == 2 and sys.argv[1].endswith(".json"):
+        # If we pass only one argument to the script and it's the path to a json file,
+        # let's parse it to get our arguments.
+        model_args, data_args, training_args = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
+    else:
+        model_args, data_args, training_args = parser.parse_args_into_dataclasses()
+
+    # Detecting last checkpoint.
+    last_checkpoint = None
+    if os.path.isdir(training_args.output_dir) and training_args.do_train and not training_args.overwrite_output_dir:
+        last_checkpoint = get_last_checkpoint(training_args.output_dir)
+        if last_checkpoint is None and len(os.listdir(training_args.output_dir)) > 0:
+            raise ValueError(
+                f"Output directory ({training_args.output_dir}) already exists and is not empty. "
+                "Use --overwrite_output_dir to overcome."
+            )
+        elif last_checkpoint is not None:
+            logger.info(
+                f"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change "
+                "the `--output_dir` or add `--overwrite_output_dir` to train from scratch."
+            )
+
+    # Setup logging
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s -   %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        handlers=[logging.StreamHandler(sys.stdout)],
+    )
+    logger.setLevel(logging.INFO if is_main_process(training_args.local_rank) else logging.WARN)
+
+    # Log on each process the small summary:
+    logger.warning(
+        f"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}"
+        + f"distributed training: {bool(training_args.local_rank != -1)}, 16-bits training: {training_args.fp16}"
+    )
+    # Set the verbosity to info of the Transformers logger (on main process only):
+    if is_main_process(training_args.local_rank):
+        transformers.utils.logging.set_verbosity_info()
+        transformers.utils.logging.enable_default_handler()
+        transformers.utils.logging.enable_explicit_format()
+    logger.info(f"Training/evaluation parameters {training_args}")
+
+    # Set seed before initializing model.
+    set_seed(training_args.seed)
+
+    # Get the datasets: you can either provide your own CSV/JSON/TXT training and evaluation files (see below)
+    # or just provide the name of one of the public datasets available on the hub at https://huggingface.co/datasets/
+    # (the dataset will be downloaded automatically from the datasets Hub).
+    #
+    # For CSV/JSON files, this script will use the column called 'text' or the first column if no column called
+    # 'text' is found. You can easily tweak this behavior (see below).
+    #
+    # In distributed training, the load_dataset function guarantee that only one local process can concurrently
+    # download the dataset.
+    # if data_args.dataset_name is not None:
+    #     # Downloading and loading a dataset from the hub.
+    #     datasets = load_dataset(data_args.dataset_name, data_args.dataset_config_name)
+    #     if "validation" not in datasets.keys():
+    #         datasets["validation"] = load_dataset(
+    #             data_args.dataset_name,
+    #             data_args.dataset_config_name,
+    #             split=f"train[:{data_args.validation_split_percentage}%]",
+    #         )
+    #         datasets["train"] = load_dataset(
+    #             data_args.dataset_name,
+    #             data_args.dataset_config_name,
+    #             split=f"train[{data_args.validation_split_percentage}%:]",
+    #         )
+    # else:
+    #     data_files = {}
+    #     if data_args.train_file is not None:
+    #         data_files["train"] = data_args.train_file
+    #     if data_args.validation_file is not None:
+    #         data_files["validation"] = data_args.validation_file
+    #     extension = (
+    #         data_args.train_file.split(".")[-1]
+    #         if data_args.train_file is not None
+    #         else data_args.validation_file.split(".")[-1]
+    #     )
+    #     if extension == "txt":
+    #         extension = "text"
+    #     datasets = load_dataset(extension, data_files=data_files)
+    datasets = load_from_disk(dataset_path=data_args.dataset_name)
+    # See more about loading any type of standard or custom dataset (from files, python dict, pandas DataFrame, etc) at
+    # https://huggingface.co/docs/datasets/loading_datasets.html.
+
+    # Load pretrained model and tokenizer
+    #
+    # Distributed training:
+    # The .from_pretrained methods guarantee that only one local process can concurrently
+    # download model & vocab.
+
+    config_kwargs = {
+        "cache_dir": model_args.cache_dir,
+        "revision": model_args.model_revision,
+        "use_auth_token": True if model_args.use_auth_token else None,
+    }
+    if model_args.config_name:
+        config = AutoConfig.from_pretrained(model_args.config_name, **config_kwargs)
+    elif model_args.model_name_or_path:
+        config = AutoConfig.from_pretrained(model_args.model_name_or_path, **config_kwargs)
+    else:
+        config = CONFIG_MAPPING[model_args.model_type]()
+        logger.warning("You are instantiating a new config instance from scratch.")
+
+    tokenizer_kwargs = {
+        "cache_dir": model_args.cache_dir,
+        "use_fast": model_args.use_fast_tokenizer,
+        "revision": model_args.model_revision,
+        "use_auth_token": True if model_args.use_auth_token else None,
+    }
+    if model_args.tokenizer_name:
+        tokenizer = AutoTokenizer.from_pretrained(model_args.tokenizer_name, **tokenizer_kwargs)
+    elif model_args.model_name_or_path:
+        tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path, **tokenizer_kwargs)
+    else:
+        raise ValueError(
+            "You are instantiating a new tokenizer from scratch. This is not supported by this script."
+            "You can do it from another script, save it, and load it from here, using --tokenizer_name."
+        )
+    if tokenizer.pad_token_id is None and tokenizer.eos_token_id is not None:
+        logger.warning(f"Setting `pad_token_id` to `eos_token_id`:{tokenizer.eos_token_id}.")
+        tokenizer.pad_token = tokenizer.eos_token
+
+    if model_args.model_name_or_path:
+        model = AutoModelForCausalLM.from_pretrained(
+            model_args.model_name_or_path,
+            from_tf=bool(".ckpt" in model_args.model_name_or_path),
+            config=config,
+            cache_dir=model_args.cache_dir,
+            revision=model_args.model_revision,
+            use_auth_token=True if model_args.use_auth_token else None,
+        )
+    else:
+        logger.info("Training new model from scratch")
+        model = AutoModelForCausalLM.from_config(config)
+
+    model.resize_token_embeddings(len(tokenizer))
+
+    # Preprocessing the datasets.
+    # First we tokenize all the texts.
+    if training_args.do_train:
+        column_names = datasets["train"].column_names
+    else:
+        column_names = datasets["validation"].column_names
+    text_column_name = "text" if "text" in column_names else column_names[0]
+
+    def tokenize_function(examples):
+        def tok_f_ids(string):
+            return tokenizer(string, return_attention_mask=False)["input_ids"]
+
+        texts, texts_a, texts_b = [], [], []
+
+        unprompted_texts = examples["text"]
+        prompting_instances = examples["prompting_instances"]
+
+        for ump_text, ppt_instances in zip(unprompted_texts, prompting_instances):
+            if ppt_instances:
+                for i, p, o in zip(ppt_instances["input"], ppt_instances["prompt"], ppt_instances["output"]):
+                    texts.append([])
+                    texts_a.append(
+                        tok_f_ids(i) \
+                        + [tokenizer.eos_token_id] \
+                        + tok_f_ids(p) \
+                        + [tokenizer.eos_token_id]
+                    )
+                    texts_b.append(tok_f_ids(o))
+            else:
+                texts.append(tok_f_ids(ump_text))
+                texts_a.append([])
+                texts_b.append([])
+        return {
+            "text_full": texts,
+            "text_a": texts_a,
+            "text_b": texts_b,
+        }
+
+    datasets = datasets.shuffle()
+    logger.info("Mapping dataset to tokenized dataset.",)
+    tokenized_datasets = datasets.map(
+        tokenize_function,
+        batched=True,
+        num_proc=data_args.preprocessing_num_workers,
+        remove_columns=column_names,
+        load_from_cache_file=not data_args.overwrite_cache,
+    )
+
+    if data_args.block_size is None:
+        block_size = tokenizer.model_max_length
+        if block_size > 1024:
+            logger.warning(
+                f"The tokenizer picked seems to have a very large `model_max_length` ({tokenizer.model_max_length}). "
+                "Picking 1024 instead. You can change that default value by passing --block_size xxx."
+            )
+            block_size = 1024
+    else:
+        if data_args.block_size > tokenizer.model_max_length:
+            logger.warning(
+                f"The block_size passed ({data_args.block_size}) is larger than the maximum length for the model"
+                f"({tokenizer.model_max_length}). Using block_size={tokenizer.model_max_length}."
+            )
+        block_size = min(data_args.block_size, tokenizer.model_max_length)
+
+    # Main data processing function that will concatenate all texts from our dataset and generate chunks of block_size.
+    def group_texts(examples):
+        texts = examples["text_full"]
+        texts_a = examples["text_a"]
+        texts_b = examples["text_b"]
+
+        result = {
+            "input_ids": [],
+            "labels": [],
+            "attention_mask": [],
+            "length": [],
+        }
+        n = int(block_size/2)
+        for t, t_a, t_b in zip(texts, texts_a, texts_b):
+            if t == []:
+                cut_t_a = t_a[-n:]
+                cut_t_b = t_b[:n]
+                if len(cut_t_b) < 20:
+                    continue
+                result["input_ids"].append(cut_t_a + cut_t_b)
+                result["labels"].append([-100]*len(cut_t_a) + cut_t_b)
+            else:
+                total_length = len(t)
+                total_length = (total_length // block_size) * block_size
+                for i in range (0, total_length, block_size):
+                    sub_seq = t[i : i + block_size]
+                    result["input_ids"].append(sub_seq)
+                    result["labels"].append(sub_seq)
+        for i in result["labels"]:
+            result["attention_mask"].append([1]*len(i))
+            result["length"].append(len(i))
+        return result
+
+    # Note that with `batched=True`, this map processes 1,000 texts together, so group_texts throws away a remainder
+    # for each of those groups of 1,000 texts. You can adjust that batch_size here but a higher value might be slower
+    # to preprocess.
+    #
+    # To speed up this part, we use multiprocessing. See the documentation of the map method for more information:
+    # https://huggingface.co/docs/datasets/package_reference/main_classes.html#datasets.Dataset.map
+
+    logger.info("Chunking tokenized dataset.")
+    lm_datasets = tokenized_datasets.map(
+        group_texts,
+        batched=True,
+        num_proc=data_args.preprocessing_num_workers,
+        remove_columns=tokenized_datasets["train"].column_names,
+        load_from_cache_file=not data_args.overwrite_cache,
+    )
+
+    if training_args.do_train:
+        if "train" not in tokenized_datasets:
+            raise ValueError("--do_train requires a train dataset")
+        train_dataset = lm_datasets["train"]
+        if data_args.max_train_samples is not None:
+            train_dataset = train_dataset.select(range(data_args.max_train_samples))
+
+    if training_args.do_eval:
+        if "validation" not in tokenized_datasets:
+            raise ValueError("--do_eval requires a validation dataset")
+        eval_dataset = lm_datasets["validation"]
+        if data_args.max_val_samples is not None:
+            eval_dataset = eval_dataset.select(range(data_args.max_val_samples))
+
+    # Initialize our Trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_dataset if training_args.do_train else None,
+        eval_dataset=eval_dataset if training_args.do_eval else None,
+        tokenizer=tokenizer,
+        # Data collator will default to DataCollatorWithPadding, so we change it.
+        data_collator=MyDataCollatorWithPadding(tokenizer=tokenizer, padding=True),
+    )
+
+    # Training
+    if training_args.do_train:
+        if last_checkpoint is not None:
+            checkpoint = last_checkpoint
+        elif model_args.model_name_or_path is not None and os.path.isdir(model_args.model_name_or_path):
+            checkpoint = model_args.model_name_or_path
+        else:
+            checkpoint = None
+        train_result = trainer.train(resume_from_checkpoint=checkpoint)
+        trainer.save_model()  # Saves the tokenizer too for easy upload
+
+        metrics = train_result.metrics
+
+        max_train_samples = (
+            data_args.max_train_samples if data_args.max_train_samples is not None else len(train_dataset)
+        )
+        metrics["train_samples"] = min(max_train_samples, len(train_dataset))
+
+        trainer.log_metrics("train", metrics)
+        trainer.save_metrics("train", metrics)
+        trainer.save_state()
+
+    # Evaluation
+    if training_args.do_eval:
+        logger.info("*** Evaluate ***")
+
+        metrics = trainer.evaluate()
+
+        max_val_samples = data_args.max_val_samples if data_args.max_val_samples is not None else len(eval_dataset)
+        metrics["eval_samples"] = min(max_val_samples, len(eval_dataset))
+        perplexity = math.exp(metrics["eval_loss"])
+        metrics["perplexity"] = perplexity
+
+        trainer.log_metrics("eval", metrics)
+        trainer.save_metrics("eval", metrics)
+
+
+def _mp_fn(index):
+    # For xla_spawn (TPUs)
+    main()
+
+
+if __name__ == "__main__":
+    main()

jz/scripts/run_text2text.py

@@ -0,0 +1,514 @@
+#!/usr/bin/env python
+# coding=utf-8
+# Copyright 2020 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Fine-tune a text-to-text model (T5, BART, ...) on a text file or dataset.
+"""
+
+import logging
+import math
+import os
+import sys
+from dataclasses import dataclass, field
+from typing import Optional
+
+import torch.distributed
+from datasets import load_dataset
+
+import transformers
+from transformers import (
+    CONFIG_MAPPING,
+    MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
+    AutoConfig,
+    AutoModelForSeq2SeqLM,
+    AutoTokenizer,
+    HfArgumentParser,
+    Trainer,
+    TrainingArguments,
+    default_data_collator,
+    set_seed,
+)
+from transformers.testing_utils import CaptureLogger
+from transformers.trainer_utils import get_last_checkpoint, is_main_process
+from transformers.utils import check_min_version
+
+### I very much dislike this solution. `run_clm.py` should probably be at the root, or install as an editable package.
+import os
+currentdir = os.path.dirname(os.path.realpath(__file__))
+parentdir = os.path.dirname(currentdir)
+sys.path.append(parentdir)
+###
+
+# Will error if the minimal version of Transformers is not installed. Remove at your own risks.
+from custom_callbacks import LogFlosCallback, TensorBoardFloIndexedCallback
+
+check_min_version("4.6.0.dev0")
+
+logging.basicConfig(
+    format="%(asctime)s - %(levelname)s - %(process)d - %(name)s - %(message)s",
+    datefmt="%m/%d/%Y %H:%M:%S",
+    level=logging.INFO,
+)
+logger = logging.getLogger(__name__)
+
+
+MODEL_CONFIG_CLASSES = list(MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING.keys())
+MODEL_TYPES = tuple(conf.model_type for conf in MODEL_CONFIG_CLASSES)
+
+
+@dataclass
+class ModelArguments:
+    """
+    Arguments pertaining to which model/config/tokenizer we are going to fine-tune, or train from scratch.
+    """
+
+    model_name_or_path: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "The model checkpoint for weights initialization."
+            "Don't set if you want to train a model from scratch."
+        },
+    )
+    model_type: Optional[str] = field(
+        default=None,
+        metadata={"help": "If training from scratch, pass a model type from the list: " + ", ".join(MODEL_TYPES)},
+    )
+    config_name: Optional[str] = field(
+        default=None, metadata={"help": "Pretrained config name or path if not the same as model_name"}
+    )
+    tokenizer_name: Optional[str] = field(
+        default=None, metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"}
+    )
+    cache_dir: Optional[str] = field(
+        default=None,
+        metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"},
+    )
+    use_fast_tokenizer: bool = field(
+        default=True,
+        metadata={"help": "Whether to use one of the fast tokenizer (backed by the tokenizers library) or not."},
+    )
+    model_revision: str = field(
+        default="main",
+        metadata={"help": "The specific model version to use (can be a branch name, tag name or commit id)."},
+    )
+    use_auth_token: bool = field(
+        default=False,
+        metadata={
+            "help": "Will use the token generated when running `huggingface-cli login` (necessary to use this script "
+            "with private models)."
+        },
+    )
+
+
+@dataclass
+class ConfigArguments:
+    """
+    Arguments defining the new model we're about to train when training from scratch
+    """
+
+    n_ctx: Optional[int] = field(default=1024, metadata={"help": "Dimensionality of the causal mask"})
+    n_embd: Optional[int] = field(
+        default=768, metadata={"help": "Dimensionality of the embeddings and hidden states."}
+    )
+    n_layer: Optional[int] = field(default=12, metadata={"help": "Number of hidden layers."})
+    n_head: Optional[int] = field(default=12, metadata={"help": "Number of attention heads for each attention layer."})
+    n_inner: Optional[int] = field(default=None, metadata={"help": "Dimensionality of the inner feed-forward layers."})
+
+
+@dataclass
+class DataTrainingArguments:
+    """
+    Arguments pertaining to what data we are going to input our model for training and eval.
+    """
+
+    sanity: bool = field(
+        default=False, metadata={"help": "Only use fraction of the dataset"}
+    )
+    dataset_name: Optional[str] = field(
+        default=None, metadata={"help": "The name of the dataset to use (via the datasets library)."}
+    )
+    dataset_config_name: Optional[str] = field(
+        default=None, metadata={"help": "The configuration name of the dataset to use (via the datasets library)."}
+    )
+    train_file: Optional[str] = field(default=None, metadata={"help": "The input training data file (a text file)."})
+    validation_file: Optional[str] = field(
+        default=None,
+        metadata={"help": "An optional input evaluation data file to evaluate the perplexity on (a text file)."},
+    )
+    max_train_samples: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": "For debugging purposes or quicker training, truncate the number of training examples to this "
+            "value if set."
+        },
+    )
+    max_val_samples: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": "For debugging purposes or quicker training, truncate the number of validation examples to this "
+            "value if set."
+        },
+    )
+
+    block_size: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": "Optional input sequence length after tokenization. "
+            "The training dataset will be truncated in block of this size for training. "
+            "Default to the model max input length for single sentence inputs (take into account special tokens)."
+        },
+    )
+    overwrite_cache: bool = field(
+        default=False, metadata={"help": "Overwrite the cached training and evaluation sets"}
+    )
+    validation_split_percentage: Optional[int] = field(
+        default=5,
+        metadata={
+            "help": "The percentage of the train set used as validation set in case there's no validation split"
+        },
+    )
+    preprocessing_num_workers: Optional[int] = field(
+        default=None,
+        metadata={"help": "The number of processes to use for the preprocessing."},
+    )
+
+    def __post_init__(self):
+        if self.dataset_name is None and self.train_file is None and self.validation_file is None:
+            raise ValueError("Need either a dataset name or a training/validation file.")
+        else:
+            if self.train_file is not None:
+                extension = self.train_file.split(".")[-1]
+                assert extension in ["csv", "json", "txt"], "`train_file` should be a csv, a json or a txt file."
+            if self.validation_file is not None:
+                extension = self.validation_file.split(".")[-1]
+                assert extension in ["csv", "json", "txt"], "`validation_file` should be a csv, a json or a txt file."
+
+
+def main():
+    # See all possible arguments in src/transformers/training_args.py
+    # or by passing the --help flag to this script.
+    # We now keep distinct sets of args, for a cleaner separation of concerns.
+
+    parser = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments, ConfigArguments))
+    if len(sys.argv) == 2 and sys.argv[1].endswith(".json"):
+        # If we pass only one argument to the script and it's the path to a json file,
+        # let's parse it to get our arguments.
+        model_args, data_args, training_args, config_args = parser.parse_json_file(
+            json_file=os.path.abspath(sys.argv[1])
+        )
+    else:
+        model_args, data_args, training_args, config_args = parser.parse_args_into_dataclasses()
+
+    # Detecting last checkpoint.
+    last_checkpoint = None
+    if os.path.isdir(training_args.output_dir) and training_args.do_train and not training_args.overwrite_output_dir:
+        last_checkpoint = get_last_checkpoint(training_args.output_dir)
+        if last_checkpoint is None and len(os.listdir(training_args.output_dir)) > 0:
+            raise ValueError(
+                f"Output directory ({training_args.output_dir}) already exists and is not empty. "
+                "Use --overwrite_output_dir to overcome."
+            )
+        elif last_checkpoint is not None:
+            logger.info(
+                f"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change "
+                "the `--output_dir` or add `--overwrite_output_dir` to train from scratch."
+            )
+
+    # Setup logging
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s -   %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        handlers=[logging.StreamHandler(sys.stdout)],
+    )
+    logger.setLevel(logging.INFO if is_main_process(training_args.local_rank) else logging.WARN)
+
+    # Log on each process the small summary:
+    logger.warning(
+        f"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}"
+        + f"distributed training: {bool(training_args.local_rank != -1)}, 16-bits training: {training_args.fp16}"
+    )
+    # Set the verbosity to info of the Transformers logger (on main process only):
+    if is_main_process(training_args.local_rank):
+        transformers.utils.logging.set_verbosity_info()
+        transformers.utils.logging.enable_default_handler()
+        transformers.utils.logging.enable_explicit_format()
+    logger.info(f"Training/evaluation parameters {training_args}")
+
+    # Set seed before initializing model.
+    set_seed(training_args.seed)
+
+    # Get the datasets: you can either provide your own CSV/JSON/TXT training and evaluation files (see below)
+    # or just provide the name of one of the public datasets available on the hub at https://huggingface.co/datasets/
+    # (the dataset will be downloaded automatically from the datasets Hub).
+    #
+    # For CSV/JSON files, this script will use the column called 'text' or the first column if no column called
+    # 'text' is found. You can easily tweak this behavior (see below).
+    #
+    # In distributed training, the load_dataset function guarantee that only one local process can concurrently
+    # download the dataset.
+    if data_args.dataset_name is not None:
+        # Downloading and loading a dataset from the hub.
+        datasets = load_dataset(data_args.dataset_name, data_args.dataset_config_name, keep_in_memory=False, cache_dir=model_args.cache_dir)
+        if "validation" not in datasets.keys():
+            datasets["validation"] = load_dataset(
+                data_args.dataset_name,
+                data_args.dataset_config_name,
+                split=f"train[:{data_args.validation_split_percentage}%]",
+                keep_in_memory=False,
+                cache_dir=model_args.cache_dir
+            )
+            datasets["train"] = load_dataset(
+                data_args.dataset_name,
+                data_args.dataset_config_name,
+                split=f"train[{data_args.validation_split_percentage}%:]",
+                keep_in_memory=False,
+                cache_dir=model_args.cache_dir
+            )
+    else:
+        data_files = {}
+        if data_args.train_file is not None:
+            data_files["train"] = data_args.train_file
+        if data_args.validation_file is not None:
+            data_files["validation"] = data_args.validation_file
+        extension = (
+            data_args.train_file.split(".")[-1]
+            if data_args.train_file is not None
+            else data_args.validation_file.split(".")[-1]
+        )
+        if extension == "txt":
+            extension = "text"
+        datasets = load_dataset(extension, data_files=data_files, keep_in_memory=False, cache_dir=model_args.cache_dir)
+    if data_args.sanity:
+        datasets["train"] = datasets["train"].shard(100, index=0, contiguous=True)
+    # See more about loading any type of standard or custom dataset (from files, python dict, pandas DataFrame, etc) at
+    # https://huggingface.co/docs/datasets/loading_datasets.html.
+
+    # Load pretrained model and tokenizer
+    #
+    # Distributed training:
+    # The .from_pretrained methods guarantee that only one local process can concurrently
+    # download model & vocab.
+
+    config_kwargs = {
+        "cache_dir": model_args.cache_dir,
+        "revision": model_args.model_revision,
+        "use_auth_token": True if model_args.use_auth_token else None,
+    }
+    if model_args.config_name:
+        config = AutoConfig.from_pretrained(model_args.config_name, **config_kwargs)
+    elif model_args.model_name_or_path:
+        config = AutoConfig.from_pretrained(model_args.model_name_or_path, **config_kwargs)
+    else:
+        config = CONFIG_MAPPING[model_args.model_type](**vars(config_args), **config_kwargs)
+        logger.warning("You are instantiating a new config instance from scratch.")
+
+    tokenizer_kwargs = {
+        "cache_dir": model_args.cache_dir,
+        "use_fast": model_args.use_fast_tokenizer,
+        "revision": model_args.model_revision,
+        "use_auth_token": True if model_args.use_auth_token else None,
+    }
+    if model_args.tokenizer_name:
+        tokenizer = AutoTokenizer.from_pretrained(model_args.tokenizer_name, **tokenizer_kwargs)
+    elif model_args.model_name_or_path:
+        tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path, **tokenizer_kwargs)
+    else:
+        raise ValueError(
+            "You are instantiating a new tokenizer from scratch. This is not supported by this script."
+            "You can do it from another script, save it, and load it from here, using --tokenizer_name."
+        )
+
+    if model_args.model_name_or_path:
+        model = AutoModelForSeq2SeqLM.from_pretrained(
+            model_args.model_name_or_path,
+            from_tf=bool(".ckpt" in model_args.model_name_or_path),
+            config=config,
+            cache_dir=model_args.cache_dir,
+            revision=model_args.model_revision,
+            use_auth_token=True if model_args.use_auth_token else None,
+        )
+    else:
+        logger.info("Training new model from scratch")
+        model = AutoModelForSeq2SeqLM.from_config(config)
+
+    model.resize_token_embeddings(len(tokenizer))
+
+    # Preprocessing the datasets.
+    # First we tokenize all the texts.
+    if training_args.do_train:
+        column_names = datasets["train"].column_names
+    else:
+        column_names = datasets["validation"].column_names
+    text_column_name = "text" if "text" in column_names else column_names[0]
+
+    # since this will be pickled to avoid _LazyModule error in Hasher force logger loading before tokenize_function
+    tok_logger = transformers.utils.logging.get_logger("transformers.tokenization_utils_base")
+
+    datasets = datasets.shuffle()
+    def tokenize_function(examples):
+        with CaptureLogger(tok_logger) as cl:
+            output = tokenizer(examples[text_column_name])
+        # clm input could be much much longer than block_size
+        if "Token indices sequence length is longer than the" in cl.out:
+            tok_logger.warning(
+                "^^^^^^^^^^^^^^^^ Please ignore the warning above - this long input will be chunked into smaller bits before being passed to the model."
+            )
+        return output
+
+    # Ensures only the main process does dataset pre-processing; the other ones will load the `map` cache
+    if not is_main_process(training_args.local_rank):
+        print("waiting for main process to execute mapping")
+        torch.distributed.barrier()
+
+    logger.info("Mapping dataset to tokenized dataset.",)
+    tokenized_datasets = datasets.map(
+        tokenize_function,
+        batched=True,
+        num_proc=data_args.preprocessing_num_workers,
+        remove_columns=column_names,
+        load_from_cache_file=not data_args.overwrite_cache,
+        keep_in_memory=False
+    )
+
+    if data_args.block_size is None:
+        block_size = tokenizer.model_max_length
+        if block_size > 1024:
+            logger.warning(
+                f"The tokenizer picked seems to have a very large `model_max_length` ({tokenizer.model_max_length}). "
+                "Picking 1024 instead. You can change that default value by passing --block_size xxx."
+            )
+            block_size = 1024
+    else:
+        if data_args.block_size > tokenizer.model_max_length:
+            logger.warning(
+                f"The block_size passed ({data_args.block_size}) is larger than the maximum length for the model"
+                f"({tokenizer.model_max_length}). Using block_size={tokenizer.model_max_length}."
+            )
+        block_size = min(data_args.block_size, tokenizer.model_max_length)
+
+    # Main data processing function that will concatenate all texts from our dataset and generate chunks of block_size.
+    def group_texts(examples):
+        # Concatenate all texts.
+        concatenated_examples = {k: sum(examples[k], []) for k in examples.keys()}
+        total_length = len(concatenated_examples[list(examples.keys())[0]])
+        # We drop the small remainder, we could add padding if the model supported it instead of this drop, you can
+        # customize this part to your needs.
+        total_length = (total_length // (2 * block_size)) * 2 * block_size
+        # Split by chunks of max_len.
+        result = {
+            k: [t[i : i + block_size] for i in range(0, total_length, 2*block_size)]
+            for k, t in concatenated_examples.items()
+        }
+        result["labels"] = [
+            concatenated_examples['input_ids'][i : i + block_size]
+            for i in range(block_size, total_length, 2*block_size)
+        ]
+        return result
+
+    # Note that with `batched=True`, this map processes 1,000 texts together, so group_texts throws away a remainder
+    # for each of those groups of 1,000 texts. You can adjust that batch_size here but a higher value might be slower
+    # to preprocess.
+    #
+    # To speed up this part, we use multiprocessing. See the documentation of the map method for more information:
+    # https://huggingface.co/docs/datasets/package_reference/main_classes.html#datasets.Dataset.map
+
+    logger.info("Chunking tokenized dataset.")
+    lm_datasets = tokenized_datasets.map(
+        group_texts,
+        batched=True,
+        num_proc=data_args.preprocessing_num_workers,
+        load_from_cache_file=not data_args.overwrite_cache,
+        keep_in_memory=False
+    )
+
+    # Now the other ones can catch up.
+    if training_args.local_rank != -1 and is_main_process(training_args.local_rank):
+        print("loading results from main process")
+        torch.distributed.barrier()
+
+    if training_args.do_train:
+        if "train" not in tokenized_datasets:
+            raise ValueError("--do_train requires a train dataset")
+        train_dataset = lm_datasets["train"]
+        if data_args.max_train_samples is not None:
+            train_dataset = train_dataset.select(range(data_args.max_train_samples))
+
+    if training_args.do_eval:
+        if "validation" not in tokenized_datasets:
+            cutoff = data_args.validation_split_percentage * len(lm_datasets["train"]) // 100
+            train_dataset = lm_datasets["train"].select(range(cutoff, len(lm_datasets["train"])))
+            eval_dataset = lm_datasets["train"].select(range(cutoff))
+        else:
+            eval_dataset = lm_datasets["validation"]
+        if data_args.max_val_samples is not None:
+            eval_dataset = eval_dataset.select(range(data_args.max_val_samples))
+
+
+    # Initialize our Trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_dataset if training_args.do_train else None,
+        eval_dataset=eval_dataset if training_args.do_eval else None,
+        tokenizer=tokenizer,
+        # Data collator will default to DataCollatorWithPadding, so we change it.
+        data_collator=default_data_collator,
+        callbacks=[LogFlosCallback, TensorBoardFloIndexedCallback]
+    )
+
+    # Training
+    if training_args.do_train:
+        checkpoint = None
+        if training_args.resume_from_checkpoint is not None:
+            checkpoint = training_args.resume_from_checkpoint
+        elif last_checkpoint is not None:
+            checkpoint = last_checkpoint
+
+        train_result = trainer.train(resume_from_checkpoint=checkpoint)
+        trainer.save_model()  # Saves the tokenizer too for easy upload
+
+        metrics = train_result.metrics
+
+        max_train_samples = (
+            data_args.max_train_samples if data_args.max_train_samples is not None else len(train_dataset)
+        )
+        metrics["train_samples"] = min(max_train_samples, len(train_dataset))
+
+        trainer.log_metrics("train", metrics)
+        trainer.save_metrics("train", metrics)
+        trainer.save_state()
+
+    # Evaluation
+    if training_args.do_eval:
+        logger.info("*** Evaluate ***")
+
+        metrics = trainer.evaluate()
+
+        max_val_samples = data_args.max_val_samples if data_args.max_val_samples is not None else len(eval_dataset)
+        metrics["eval_samples"] = min(max_val_samples, len(eval_dataset))
+        perplexity = math.exp(metrics["eval_loss"])
+        metrics["perplexity"] = perplexity
+
+        trainer.log_metrics("eval", metrics)
+        trainer.save_metrics("eval", metrics)
+
+
+def _mp_fn(index):
+    # For xla_spawn (TPUs)
+    main()
+
+
+if __name__ == "__main__":
+    main()

jz/slurms_scripts/cpu.slurm

@@ -0,0 +1,40 @@
+#!/bin/bash
+#SBATCH --job-name=second_lm_balanced_prompted # job name
+#SBATCH --ntasks=1                   # number of MP task
+#SBATCH --cpus-per-task=32           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --time=20:00:00              # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out          # output file name
+#SBATCH --error=%x-%j.err           # error file name
+#SBATCH --account=ajs@cpu
+#SBATCH --mail-type=ALL
+
+set -x -e
+
+DATASET=wiki_bk_prompted
+SERIALIZATION_DIR=${ALL_CCFRSCRATCH}/experiments/preprocess_data
+
+source ~/.bashrc
+conda activate smallexps
+export TOKENIZERS_PARALLELISM=false
+export PYTHONUNBUFFERED=true
+export HF_DATASETS_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+
+python ${WORK}/jay-z/scripts/run_clm_prompted.py \
+    --model_name_or_path gpt2-medium \
+    --tokenizer_name gpt2 \
+    --dataset_name ${ALL_CCFRSCRATCH}/datasets/${DATASET} --block_size 1024 \
+    --preprocessing_num_workers 31 \
+    --group_by_length --length_column_name length \
+    --cache_dir ${CACHE_DIR} \
+    --do_train --do_eval \
+    --max_steps 15000 \
+    --max_train_samples 10000000 \
+    --per_device_train_batch_size 4 --gradient_accumulation_steps 16 \
+    --per_device_eval_batch_size 8 \
+    --output_dir ${SERIALIZATION_DIR} --overwrite_output_dir \
+    --report_to tensorboard \
+    --logging_strategy steps --logging_first_step --logging_dir tb --logging_steps 20 \
+    --eval_steps 250 --evaluation_strategy steps \
+    --save_strategy steps --save_steps 500 --save_total_limit 31

jz/slurms_scripts/eval.slurm

@@ -0,0 +1,37 @@
+#!/bin/bash
+#SBATCH --job-name=eval-array         # job name
+#SBATCH --qos=qos_gpu-t3              # t3 enables 20h jobs but on 512 GPUs
+#SBATCH --ntasks=1                    # number of MP tasks
+#SBATCH --gres=gpu:4                  # number of GPUs per node
+#SBATCH --cpus-per-task=40            # number of cores per tasks
+#SBATCH -C v100-16g
+#SBATCH --array=500-17000:1000%26     # array of values
+#SBATCH --hint=nomultithread          # we get physical cores not logical
+#SBATCH --time=04:00:00               # maximum execution time (HH:MM:SS)
+#SBATCH --output=std-eval-%A_%a.out   # output file name
+#SBATCH --error=std-eval-%A_%a.out    # error file name
+#SBATCH --account=six@gpu
+#SBATCH --mail-type=ALL
+
+set -x -e
+
+source $six_ALL_CCFRWORK/start-prod
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+export HF_DATASETS_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+
+DATASET=openwebtext
+SERIALIZATION_DIR=${eha_ALL_CCFRSCRATCH}/experiments/dec_only_t5-tiny
+
+python -m torch.distributed.launch --nproc_per_node 4 ${six_ALL_CCFRWORK/code/bigscience/jz/scripts/run_clm.py \
+    --model_name_or_path ${SERIALIZATION_DIR}/checkpoint-${SLURM_ARRAY_TASK_ID} \
+    --tokenizer_name t5-small \
+    --dataset_name ${DATASET} --block_size 1024 \
+    --preprocessing_num_workers 76 \
+    --do_eval \
+    --per_device_eval_batch_size 16 \
+    --output_dir ${SERIALIZATION_DIR}/checkpoint-${SLURM_ARRAY_TASK_ID} \
+    --report_to tensorboard --logging_dir ${SERIALIZATION_DIR}/checkpoint-${SLURM_ARRAY_TASK_ID}

jz/slurms_scripts/lmt5.slurm

@@ -0,0 +1,51 @@
+#!/bin/bash
+#SBATCH --job-name=lmt5medium
+#SBATCH --partition=gpu_p2
+#SBATCH --qos=qos_gpu-t4              # t4 enables 100H trainings
+#SBATCH --ntasks=1                    # number of MP tasks
+#SBATCH --gres=gpu:8                  # number of GPUs per node
+#SBATCH --cpus-per-task=24            # number of cores per tasks
+#SBATCH --hint=nomultithread          # we get physical cores not logical
+#SBATCH --time=100:00:00              # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out               # output file name
+#SBATCH --error=%x-%j.out                # error file name (same to watch just one file)
+#SBATCH --account=six@gpu
+#SBATCH --mail-type=ALL
+
+set -x -e
+
+source $six_ALL_CCFRWORK/start-prod
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+export HF_DATASETS_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+
+DATASET=openwebtext
+LOGG_FREQUENCY=125
+SAVE_FREQUENCY=250
+EVAL_FREQUENCY=1000
+SERIALIZATION_DIR=${eha_ALL_CCFRSCRATCH}/experiments/lm_t5-medium
+LOGGING_DIR=${eha_ALL_CCFRSCRATCH}/tensorboard/lm_t5-medium
+
+deepspeed ${six_ALL_CCFRWORK/code/bigscience/jz/scripts/run_text2text.py \
+  --deepspeed ${six_ALL_CCFRWORK/code/bigscience/jz/configs/deepspeed/ds_zero3.json \
+  --model_type t5 \
+  --tokenizer_name t5-small \
+  --config_name ${six_ALL_CCFRWORK/code/bigscience/jz/configs/lm_t5/lm_t5-medium.json \
+  --dataset_name ${DATASET} --block_size 512 \
+  --preprocessing_num_workers 76 \
+  --do_train --do_eval \
+  --max_steps 34000 \
+  --per_device_train_batch_size 4 --gradient_accumulation_steps 8 \
+  --per_device_eval_batch_size 4 \
+  --learning_rate 3e-4 \
+  --adam_beta1 0.9 --adam_beta2 0.95 --weight_decay 0.1 \
+  --warmup_steps 800 \
+  --max_grad_norm 1.0 \
+  --output_dir ${SERIALIZATION_DIR} --overwrite_output_dir \
+  --report_to tensorboard \
+  --logging_strategy steps --logging_first_step --logging_dir ${LOGGING_DIR} --logging_steps ${LOGG_FREQUENCY} \
+  --eval_steps ${EVAL_FREQUENCY} --evaluation_strategy steps --max_val_samples 10000 \
+  --save_strategy steps --save_steps ${SAVE_FREQUENCY} --save_total_limit 200

train/arch-and-scaling-template.slurm

@@ -0,0 +1,186 @@
+#!/bin/bash
+#SBATCH --job-name=1B3.slurm
+#SBATCH --qos=qos_gpu-t3
+#SBATCH --nodes=16
+#SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
+#SBATCH --cpus-per-task=40         # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --gres=gpu:4                 # number of gpus
+#SBATCH --time 20:00:00              # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --error=%x-%j.out            # error file name (same to watch just one file)
+#SBATCH --account=six@v100
+
+set -x -e
+
+
+# TODO: modify these for your training setup, just Ctrl-F replace <YOUR_TRAINING_NAME>
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/synched_exps/<YOUR_TRAINING_NAME>
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints
+REPO_PATH=$DATA_OUTPUT_PATH/<YOUR_TRAINING_NAME>-logs
+TENSORBOARD_PATH=$REPO_PATH/tensorboard
+CODECARBON_PATH=$REPO_PATH/codecarbon
+LOGS_PATH=$REPO_PATH/logs
+# You need to git clone the Megatron-DeepSpeed
+MEGATRON_DEEPSPEED_REPO=$six_ALL_CCFRWORK/code/Megatron-DeepSpeed
+
+# TODO: you may change the dataset, some examples are at tr3-1B3-baseline (tr3 = c4 + t5-tokenizer, tr3m = the Pile)
+VOCAB_FILE=$MEGATRON_DEEPSPEED_REPO/data/gpt2-vocab.json
+MERGE_FILE=$MEGATRON_DEEPSPEED_REPO/data/gpt2-merges.txt
+DATA_PATH=$six_ALL_CCFRWORK/datasets-custom/oscar-en/meg-gpt2_text_document
+
+# defining the right environment variables
+source $six_ALL_CCFRWORK/start-prod
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+export HF_DATASETS_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+cd $MEGATRON_DEEPSPEED_REPO
+
+# testing for potential faulty nodes
+srun --jobid $SLURM_JOBID bash -c 'python -c "import torch, socket; print(socket.gethostname(), torch.cuda.is_available())"'
+
+# so processes know who to talk to
+MASTER_ADDR=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1`
+MASTER_PORT=6000
+
+# TODO: this is our base config for 1B3, edit PP/TP/batch size/model config if smaller or bigger
+GPUS_PER_NODE=4
+NNODES=16
+PP_SIZE=2 # NLAYERS must be a multiple of PP_SIZE here
+TP_SIZE=1 # always fixed to the size of a single node
+DP_SIZE=$((NNODES*GPUS_PER_NODE/(PP_SIZE*TP_SIZE))) # will get derived automatically by trainer
+
+MICRO_BATCH_SIZE=1
+GLOBAL_BATCH_SIZE=512
+TRAIN_ITER=73_242_187
+
+NLAYERS=24
+NHIDDEN=2048
+NHEADS=16
+FFN_HIDDEN_SIZE=8192
+SEQ_LEN=2048
+
+SAVE_INTERVAL=1500
+
+OPTIMIZER_ARGS=" \
+    --optimizer adam \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.999 \
+    --adam-eps 1e-8 \
+    --lr 2e-4 \
+    --min-lr 1e-5 \
+    --lr-decay-style cosine \
+    --lr-warmup-samples 183_105 \
+    --clip-grad 1.0 \
+    --weight-decay 1e-1 \
+    "
+
+EXIT_OPTS=" \
+    --exit-duration-in-mins 1190 \
+    "
+
+GPT_ARGS=" \
+    --num-layers $NLAYERS \
+    --hidden-size $NHIDDEN \
+    --num-attention-heads $NHEADS \
+    --ffn-hidden-size $FFN_HIDDEN_SIZE \
+    --seq-length $SEQ_LEN \
+    --max-position-embeddings $SEQ_LEN \
+    --micro-batch-size $MICRO_BATCH_SIZE \
+    --global-batch-size $GLOBAL_BATCH_SIZE \
+    --rampup-batch-size 32 32 2_000_000 \
+    --train-samples $TRAIN_ITER \
+    --vocab-file $VOCAB_FILE \
+    --merge-file $MERGE_FILE \
+    --loss-scale 12 \
+    --clip-grad 1.0 \
+    --fp16 \
+    --checkpoint-activations \
+    $OPTIMIZER_ARGS \
+    $EXIT_OPTS \
+    "
+
+OUTPUT_ARGS=" \
+    --log-interval 200 \
+    --save-interval $SAVE_INTERVAL \
+    --eval-interval 1000 \
+    --eval-iters 100 \
+    --tensorboard-dir $TENSORBOARD_PATH \
+    --tensorboard-queue-size 5 \
+    --log-timers-to-tensorboard \
+    --log-batch-size-to-tensorboard \
+    --log-validation-ppl-to-tensorboard \
+    "
+# TODO: Add --codecarbon-dir $CODECARBON_PATH \ if you want to use codecarbon, not adding it for now to make the current
+# series of experiments consistent, especially speed-wise. Adding it once Tr6 and Tr7 are done
+
+ZERO_STAGE=1
+
+config_json="./ds_config.$SLURM_JOBID.json"
+
+# Deepspeed figures out GAS dynamically from dynamic GBS via set_train_batch_size()
+cat <<EOT > $config_json
+{
+  "train_micro_batch_size_per_gpu": $MICRO_BATCH_SIZE,
+  "train_batch_size": $GLOBAL_BATCH_SIZE,
+  "gradient_clipping": 1.0,
+  "zero_optimization": {
+    "stage": $ZERO_STAGE
+  },
+  "fp16": {
+    "enabled": true,
+    "loss_scale": 0,
+    "loss_scale_window": 500,
+    "hysteresis": 2,
+    "min_loss_scale": 1,
+    "initial_scale_power": 12
+  },
+  "steps_per_print": 2000,
+  "wall_clock_breakdown": false
+}
+EOT
+
+
+DEEPSPEED_ARGS=" \
+    --deepspeed \
+    --deepspeed_config ${config_json} \
+    --zero-stage ${ZERO_STAGE} \
+    --deepspeed-activation-checkpointing \
+    "
+
+export LAUNCHER="python -u -m torch.distributed.launch \
+    --nproc_per_node $GPUS_PER_NODE \
+    --nnodes $NNODES \
+    --master_addr $MASTER_ADDR \
+    --master_port $MASTER_PORT \
+    "
+
+export CMD=" \
+    `pwd`/pretrain_gpt.py \
+    --tensor-model-parallel-size $TP_SIZE \
+    --pipeline-model-parallel-size $PP_SIZE \
+    $GPT_ARGS \
+    $OUTPUT_ARGS \
+    --save $CHECKPOINT_PATH \
+    --load $CHECKPOINT_PATH \
+    --data-path $DATA_PATH \
+    --data-impl mmap \
+    --split 949,50,1 \
+    --distributed-backend nccl \
+     $DEEPSPEED_ARGS \
+    "
+
+
+# # clear old checkpoint as it'd mismatch while we sort things out
+#     rm -rf $SAVE_CHECKPOINT_PATH
+
+
+echo $CMD
+
+# We create the folder where the logs and codecarbon will be stored.
+mkdir -p $LOGS_PATH
+# to debug - add echo (it exits and prints what it would have launched)
+srun --jobid $SLURM_JOBID bash -c '$LAUNCHER --node_rank $SLURM_PROCID $CMD' 2>&1 | tee -a $LOGS_PATH/main_log.txt

train/fixes.md

@@ -0,0 +1,70 @@
+# Fixing things
+
+## Fix multiple checkpoints per branch on hub
+
+Update all `config.json` files:
+
+```
+cd /gpfsssd/scratch/rech/six/commun/experiments/fix-config/
+export GIT_LFS_SKIP_SMUDGE=1
+git clone https://huggingface.co/bigscience/tr3e-1B3-c4-checkpoints
+cd tr3e-1B3-c4-checkpoints
+~/prod/code/bigscience/tools/hub-sync.py --repo-path . --patterns '*bogus*'
+set +H
+git branch -a | sort -V | perl -lne 'm|(global_step\d+)| && print qx[git checkout $1; perl -pi -e "s/gelu(?!_)/gelu_fast/" $1/config.json; git commit -m "gelu_fast is the correct activation_function" .; git push --set-upstream origin $1]'
+export GIT_LFS_SKIP_SMUDGE=0
+```
+
+```
+cd /gpfsssd/scratch/rech/six/commun/experiments/fix-config/
+export GIT_LFS_SKIP_SMUDGE=1
+git clone https://huggingface.co/bigscience/tr3d-1B3-oscar-checkpoints
+cd tr3d-1B3-oscar-checkpoints
+~/prod/code/bigscience/tools/hub-sync.py --repo-path . --patterns '*bogus*'
+set +H
+git branch -a | sort -V | perl -lne 'm|(global_step\d+)| && print qx[git checkout $1; perl -pi -e "s/gelu(?!_)/gelu_fast/" $1/config.json; git commit -m "gelu_fast is the correct activation_function" .; git push --set-upstream origin $1]'
+export GIT_LFS_SKIP_SMUDGE=0
+```
+
+
+```
+cd /gpfsssd/scratch/rech/six/commun/experiments/fix-config/
+export GIT_LFS_SKIP_SMUDGE=1
+git clone https://huggingface.co/bigscience/tr3m-1B3-pile-checkpoints
+cd tr3m-1B3-pile-checkpoints
+set +H
+~/prod/code/bigscience/tools/hub-sync.py --repo-path . --patterns '*bogus*'
+git branch -a | sort -V | perl -lne 'm|(global_step\d+)| && print qx[git checkout $1; perl -pi -e "s/gelu(?!_)/gelu_fast/" $1/config.json; git commit -m "gelu_fast is the correct activation_function" .; git push --set-upstream origin $1]'
+export GIT_LFS_SKIP_SMUDGE=0
+```
+
+## Fix corrupted git
+
+
+Quite a few times now we had an odd git corruption for the logging repos:
+
+
+```
+OSError: error: invalid object 100644 e69f03783ce2b0af675405f22b49ebeb56d907e5 for '.gitattributes'
+error: invalid object 100644 e69f03783ce2b0af675405f22b49ebeb56d907e5 for '.gitattributes'
+error: Error building trees
+```
+
+Of course, the error can be different.
+
+Perhaps slurm somehow occasionally kills the syncing process while git is doing something internally and thus corrupts it. It's hard to tell.
+
+You can fix these easily but making a new clone and swapping in just the `.git` dir. That fixes it up.
+
+Here is the full process using `tr8b-104B-logs` as an example:
+
+```
+cd checkpoints/tr8b-104B/
+git clone https://huggingface.co/bigscience/tr8b-104B-logs/ tr8b-104B-logs-new
+mkdir trash
+mv tr8b-104B-logs/.git trash
+cp -r tr8b-104B-logs-new/.git tr8b-104B-logs/.git
+# check that it is no longer broken
+cd tr8b-104B-logs
+git gc
+```

train/lessons-learned.md

@@ -0,0 +1,88 @@
+# Lessons learned
+
+The following are super-brief summary notes. If you want the details with graphs and full notes, see:
+
+13B:
+* [chronicles](./tr1-13B-base/chronicles.md)
+
+104B:
+* [chronicles a](./tr8-104B-wide/chronicles.md)
+* [chronicles b](./tr8b-104B/chronicles.md)
+
+## How training divergences were overcome
+
+The following are techniques that have to be done before the training starts.
+
+### Using a formulaic std init
+
+Setting `--init-method-std` to `sqrt(2/(NHIDDEN*5))` has made a huge difference to the training stability.
+
+e.g. for `NHIDDEN=11600` we used  `--init-method-std 0.006`
+
+We derived this from:
+
+`0.00587220219514703 = sqrt(2/(11600*5))` (from the "Transformers without Tears" paper https://arxiv.org/abs/1910.05895)
+
+If you are wondering why the depth of the model is not included in this month, it's then used by the framework internally via a [second std init function](https://github.com/bigscience-workshop/Megatron-DeepSpeed/blob/40e8b2a086f98920de692ebc4081bf4229bfa81a/megatron/model/utils.py#L33-L40) which rescales the std of the second layer in the MLP and the output layer of the attention with:
+```
+std = sigma / math.sqrt(2.0 * num_layers)
+```
+where `sigma` is the `--init-method-std` argument.
+
+Note that Megatron-Deepspeed 530B Training used an even smaller init of `sqrt(1/(NHIDDEN*3))`. [Reference](https://arxiv.org/abs/2201.11990). (so their co-efficient under `sqrt` is 0.333 and ours is 0.4).
+
+
+### Adding embed layernorm
+
+Embedding LayerNorm has shown to help a lot with spikes that the training can't recover from. This insight came from experimenting with https://github.com/facebookresearch/bitsandbytes which contains a `StableEmbedding` which is a normal Embedding with layernorm and it uses a uniform xavier initialization.
+
+To activate add `--embed-layernorm`
+
+Note: since this has its weights you can only add it at the beginning of the training
+
+Note: since this is not part of the normal HF GPT2, this will require a new arch or a config that adds a layer-norm to the GPT2 model.
+
+
+### Using a Lower LR
+
+- halving lr from 6e-5 to 3e-5 also proved fruitful, but it went through a huge spike at iteration 11.5k and took ~2k iterations to recover (exp 11) at which point it was put on hold and other approaches were experimented with.
+
+
+### Patience
+
+In some cases in the case of a huge spike it was taking 2k iterations for a training to return to the same lm loss it spiked from. And then it'd continue training as if nothing happened.
+
+But more often than not the training won't recover from a spike.
+
+Yet in other situations the training diverged slowly without any spikes.
+
+
+## How to deal with ongoing instabilities
+
+How to recover from an instability without a full restart.
+
+### Data skipping
+
+1. Roll back to the last checkpoint before the instability
+2. skip data samples from the instability window `--skip-train-iteration-range 8401-8800 `
+
+### LR Changing
+
+Normally LR-related params can't be changed once training has started (Megatron asserts) but with `--override-lr-scheduler` we can completely rewrite them and it just works. that is megatron recalculates everything based on cmd line args and sets the LR to the right setting which can be very different from what it'd have normally been.
+
+So for example now we can rollback a bit and change LR if we need to to try to overcome some rough patch of data or some other instability.
+
+
+## What was tried and it didn't work
+
+- changing seed - the problem usually would just shift elsewhere - but it might work in some situation where data skipping worked
+
+- a more numerically stable self-attention version by multiplying the two matrices passed to `torch.baddbmm` by `1.0/math.sqrt(self.norm_factor)` and then using `alpha=1.0`
+
+- lowering `beta2` to 0.95 (from 0.999)
+
+- changing width/depth ratio
+
+- longer lr warmup
+
+- tried Curriculum Learning

train/tflops_optimization.md

@@ -0,0 +1,33 @@
+## Rule of thumb for optimizing TFLOPS
+
+Given n gpus, we're interested in finding the configuration that allows us to run the model the fastest:
+
+When to use DP:
+ - Whenever you can. Use as much DP as you can.
+ - It does have a negative impact if the number `$GBS / $MBS` is close to DP as you end up losing pipeline efficiency
+
+When to use TP:
+ - When the largest layer does not fit into a single gpu (along with all the activation, optimizer states and gradient memory).
+ - TP is communication heavy, so you should never go beyond the number of gpus available in a single node
+
+When to use PP:
+ - When the entire model doesn't fit in a single gpu.
+
+The recipe goes as follow:
+ 1) Determine TP*PP (we'll refer to this value as MP later on):
+    1) Try and compare with some existing similar architecture (13B GPT needed 8 GPUS for one replica, ie TP*DP = 8)
+       1) The factor in model size should be roughly the same as the factor in gpus
+    2) Empiric rule: model_size*18 < 75% of gpu (to take in account additional activation memory)
+       1) If that is `True` then you don't need any model parallelism
+    3) Test different configurations with a single replica starting from TP=1/PP=1 with a single replica (DP=1) until you don't have OOM errors
+ 2) You usually want PP=$MP unless a single layer doesn't fit in a single gpu in which case TP is necessary:
+    1) You can use the rule the empiric rule in 1.ii for single layers to get an idea if you need TP or not.
+
+Bear in mind that this is just guidelines that will help you to quickly narrow down the configuration options. But you should still try a few different configurations and see which one gives the best throughput.
+
+Also watch the gpu memory usage by logging into one of the nodes. You don't want it to be too close to the max. And also you don't want to have a lot of free gpu memory available. If there is then you can tune things up more to squeeze a higher gpu utilization. e.g. you can benchmark raising MBS to use the free memory. But test the impact, since it doesn't always make things faster.
+
+Additionally, be aware of [the different constraints](https://github.com/bigscience-workshop/bigscience/blob/master/train/sanity-checks.md).
+
+Here is [how to calculate TFLOPs](https://github.com/bigscience-workshop/bigscience/tree/master/math#calculate-tflops).
+

train/tr13-mtf/smaller_models/tr13-6b3-mtf-xp3zhmt.slurm

@@ -0,0 +1,211 @@
+#!/bin/bash
+#SBATCH --job-name=xp3zhmt
+#SBATCH --partition=gpu_p5
+#SBATCH --constraint=a100
+#SBATCH --reservation=hug
+#SBATCH --qos=qos_gpu-gc             # up to 100h
+#SBATCH --nodes=8
+#SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
+#SBATCH --cpus-per-task=64           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --gres=gpu:8                 # number of gpus
+#SBATCH --time 80:00:00             # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --account=six@a100
+
+set -x -e
+
+source $six_ALL_CCFRWORK/start-tr13f-6B3-ml-t0
+echo "START TIME: $(date)"
+
+variant=xp3zhmt
+
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr13f-6B3-ml-t0
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints/$variant
+REPO_PATH=$DATA_OUTPUT_PATH/tr13f-6B3-ml-t0-logs
+TENSORBOARD_PATH=$REPO_PATH/tensorboard/$variant
+LOGS_PATH=$REPO_PATH/logs/$variant
+mkdir -p $LOGS_PATH
+mkdir -p $TENSORBOARD_PATH
+
+MEGATRON_DEEPSPEED_REPO=/gpfswork/rech/six/commun/code/tr13f-6B3-ml-t0/megdslossseqnew/Megatron-DeepSpeed
+cd $MEGATRON_DEEPSPEED_REPO
+
+KILL_SWITCH_PATH=$MEGATRON_DEEPSPEED_REPO/kill-switch-tr13f-6B3-mtf
+
+TRAIN_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3zhmt_train.txt
+VALID_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3zhmt_validation_pretr.txt
+TOKENIZER_NAME_OR_PATH=bigscience/tokenizer
+
+# defining the right environment variables
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+export HF_DATASETS_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+
+# testing for potential faulty nodes
+# srun --jobid $SLURM_JOBID bash -c 'python -c "import torch, socket; print(socket.gethostname(), torch.cuda.is_available())"'
+
+# so processes know who to talk to
+MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)
+MASTER_PORT=6001
+
+GPUS_PER_NODE=8
+NNODES=$SLURM_NNODES
+
+PP_SIZE=1
+TP_SIZE=1
+
+# T0 paper:
+# ...truncate input and target sequences to 1024 and 256 tokens...
+# ...use a batch size of 1024 sequences ... 2^20 total input tokens per batch...
+# We use 2048 total tokens and 512 batch size = 2**20
+MICRO_BATCH_SIZE=4
+GLOBAL_BATCH_SIZE=2048
+
+NLAYERS=30
+NHIDDEN=4096
+NHEADS=32
+SEQ_LEN=2048
+# 250
+SAVE_INTERVAL=2
+
+TRAIN_SAMPLES=6_348_800
+
+# T0 paper:
+# "...we use a learning rate of 1e-3..."
+# However, they use Adafactor, which adapts the LR
+# For Adam we likely want a lower one
+# FLAN:
+# "...decay of 1e-4..""
+
+# Uncomment for the first step
+# --no-load-optim \
+OPTIMIZER_ARGS=" \
+    --optimizer adam \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.95 \
+    --adam-eps 1e-8 \
+    --lr 2e-5 \
+    --lr-decay-style constant \
+    --lr-warmup-samples 0 \
+    --clip-grad 1.0 \
+    --weight-decay 1e-4 \
+    --no-load-optim \
+    --norm-target-loss \
+    "
+# for 20h 1190, for 100h 5990
+#    --exit-duration-in-mins 1190 \
+EXIT_OPTS=" \
+    --exit-duration-in-mins 5990 \
+    "
+
+GPT_ARGS=" \
+    --pp-partition-method 'type:transformer|embedding' \
+    --num-layers $NLAYERS \
+    --hidden-size $NHIDDEN \
+    --num-attention-heads $NHEADS \
+    --seq-length $SEQ_LEN \
+    --max-position-embeddings $SEQ_LEN \
+    --micro-batch-size $MICRO_BATCH_SIZE \
+    --global-batch-size $GLOBAL_BATCH_SIZE \
+    --train-samples $TRAIN_SAMPLES \
+    --tokenizer-type PretrainedFromHF \
+    --tokenizer-name-or-path $TOKENIZER_NAME_OR_PATH \
+    --init-method-std 0.0048 \
+    --embed-layernorm \
+    --fp16 \
+    --seed 42 \
+    --position-embedding-type alibi \
+    --checkpoint-activations \
+    --abort-on-unmet-fused-kernel-constraints \
+    --kill-switch-path $KILL_SWITCH_PATH \
+    --pad-vocab-size-to 250880 \
+    $OPTIMIZER_ARGS \
+    $EXIT_OPTS \
+    "
+
+OUTPUT_ARGS=" \
+    --log-interval 1 \
+    --save-interval $SAVE_INTERVAL \
+    --eval-interval 125 \
+    --eval-iters 10 \
+    --tensorboard-dir $TENSORBOARD_PATH \
+    --tensorboard-queue-size 5 \
+    --log-timers-to-tensorboard \
+    --log-batch-size-to-tensorboard \
+    --log-validation-ppl-to-tensorboard \
+    "
+
+ZERO_STAGE=1
+
+config_json="./ds_config.$SLURM_JOBID.json"
+
+# Deepspeed figures out GAS dynamically from dynamic GBS via set_train_batch_size()
+cat <<EOT > $config_json
+{
+  "train_micro_batch_size_per_gpu": $MICRO_BATCH_SIZE,
+  "train_batch_size": $GLOBAL_BATCH_SIZE,
+  "gradient_clipping": 1.0,
+  "zero_optimization": {
+    "stage": $ZERO_STAGE
+  },
+  "fp16": {
+    "enabled": true,
+    "loss_scale": 0,
+    "loss_scale_window": 500,
+    "hysteresis": 2,
+    "min_loss_scale": 1,
+    "initial_scale_power": 12
+  },
+  "steps_per_print": 2000,
+  "wall_clock_breakdown": false
+}
+EOT
+
+
+DEEPSPEED_ARGS=" \
+    --deepspeed \
+    --deepspeed_config ${config_json} \
+    --zero-stage ${ZERO_STAGE} \
+    --deepspeed-activation-checkpointing \
+    "
+
+export LAUNCHER="python -u -m torch.distributed.run \
+    --nproc_per_node $GPUS_PER_NODE \
+    --nnodes $NNODES \
+    --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT \
+    --rdzv_backend c10d \
+    --max_restarts 0 \
+    --tee 3 \
+    "
+
+export CMD=" \
+    `pwd`/finetune_t0.py \
+    --tensor-model-parallel-size $TP_SIZE \
+    --pipeline-model-parallel-size $PP_SIZE \
+    $GPT_ARGS \
+    $OUTPUT_ARGS \
+    --save $CHECKPOINT_PATH \
+    --load $CHECKPOINT_PATH \
+    --train-weighted-split-paths-path $TRAIN_DATA_PATH \
+    --valid-weighted-split-paths-path $VALID_DATA_PATH \
+    --dataloader-type single \
+    --data-impl mmap \
+    --distributed-backend nccl \
+     $DEEPSPEED_ARGS \
+    "
+
+echo $CMD
+
+# do not remove or the training will hang and nodes will be lost w/o this workaround
+export CUDA_LAUNCH_BLOCKING=1
+
+# hide duplicated errors using this hack - will be properly fixed in pt-1.12
+export TORCHELASTIC_ERROR_FILE=/tmp/torch-elastic-error.json
+
+clear; srun --jobid $SLURM_JOBID bash -c "$LAUNCHER --node_rank \$SLURM_PROCID $CMD" 2>&1 | tee -a $LOGS_PATH/main_log.txt
+
+echo "END TIME: $(date)"

train/tr13-mtf/smaller_models/tr13e-350m-mtf-xp3capmixnewcodelonglossseq-a100.slurm

@@ -0,0 +1,212 @@
+#!/bin/bash
+#SBATCH --job-name=xp3capmixnewcodelong350m
+#SBATCH --partition=gpu_p5
+#SBATCH --constraint=a100
+#SBATCH --qos=qos_gpu-gc             # up to 100h
+#SBATCH --nodes=4
+#SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
+#SBATCH --cpus-per-task=64           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --gres=gpu:8                 # number of gpus
+#SBATCH --time 100:00:00             # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --account=six@a100
+
+set -x -e
+
+source $six_ALL_CCFRWORK/start-tr13f-6B3-ml-t0
+echo "START TIME: $(date)"
+
+variant=xp3capmixnewcodelonglossseq
+
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr13e-350M-ml-t0
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints/$variant
+REPO_PATH=$DATA_OUTPUT_PATH/tr13e-350M-ml-logs
+TENSORBOARD_PATH=$REPO_PATH/tensorboard/$variant
+LOGS_PATH=$REPO_PATH/logs/$variant
+mkdir -p $LOGS_PATH
+mkdir -p $TENSORBOARD_PATH
+
+MEGATRON_DEEPSPEED_REPO=/gpfswork/rech/six/commun/code/tr13f-6B3-ml-t0/megdslossseqnew350m/Megatron-DeepSpeed
+cd $MEGATRON_DEEPSPEED_REPO
+
+KILL_SWITCH_PATH=$MEGATRON_DEEPSPEED_REPO/kill-switch-tr13e-350M-mtf
+
+TRAIN_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3capmixnewcodelong_train.txt
+VALID_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3capmixnewcodelong_validation_pretr.txt
+TOKENIZER_NAME_OR_PATH=bigscience/tokenizer
+
+# defining the right environment variables
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+export HF_DATASETS_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+
+# testing for potential faulty nodes
+# srun --jobid $SLURM_JOBID bash -c 'python -c "import torch, socket; print(socket.gethostname(), torch.cuda.is_available())"'
+
+# so processes know who to talk to
+MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)
+MASTER_PORT=6001
+
+GPUS_PER_NODE=8
+NNODES=$SLURM_NNODES
+
+PP_SIZE=1
+TP_SIZE=1
+
+# T0 paper:
+# ...truncate input and target sequences to 1024 and 256 tokens...
+# ...use a batch size of 1024 sequences ... 2^20 total input tokens per batch...
+# We use 2048 total tokens and 512 batch size = 2**20
+MICRO_BATCH_SIZE=1
+GLOBAL_BATCH_SIZE=1024
+
+NLAYERS=24
+NHIDDEN=1024
+NHEADS=16
+SEQ_LEN=2048
+# 250
+SAVE_INTERVAL=2
+
+TRAIN_SAMPLES=6_348_800
+
+# T0 paper:
+# "...we use a learning rate of 1e-3..."
+# However, they use Adafactor, which adapts the LR
+# For Adam we likely want a lower one
+# FLAN:
+# "...decay of 1e-4..""
+
+# Uncomment for the first step
+# --no-load-optim \
+# --reset-progress \
+OPTIMIZER_ARGS=" \
+    --optimizer adam \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.95 \
+    --adam-eps 1e-8 \
+    --lr 2e-5 \
+    --lr-decay-style constant \
+    --lr-warmup-samples 0 \
+    --clip-grad 1.0 \
+    --weight-decay 1e-4 \
+    --no-load-optim \
+    --reset-progress \
+    --norm-target-loss \
+    "
+# for 20h 1190, for 100h 5990
+#    --exit-duration-in-mins 1190 \
+EXIT_OPTS=" \
+    --exit-duration-in-mins 5990 \
+    "
+
+GPT_ARGS=" \
+    --pp-partition-method 'type:transformer|embedding' \
+    --num-layers $NLAYERS \
+    --hidden-size $NHIDDEN \
+    --num-attention-heads $NHEADS \
+    --seq-length $SEQ_LEN \
+    --max-position-embeddings $SEQ_LEN \
+    --micro-batch-size $MICRO_BATCH_SIZE \
+    --global-batch-size $GLOBAL_BATCH_SIZE \
+    --train-samples $TRAIN_SAMPLES \
+    --tokenizer-type PretrainedFromHF \
+    --tokenizer-name-or-path $TOKENIZER_NAME_OR_PATH \
+    --init-method-std 0.0048 \
+    --embed-layernorm \
+    --fp16 \
+    --seed 42 \
+    --position-embedding-type alibi \
+    --checkpoint-activations \
+    --abort-on-unmet-fused-kernel-constraints \
+    --kill-switch-path $KILL_SWITCH_PATH \
+    --pad-vocab-size-to 250880 \
+    $OPTIMIZER_ARGS \
+    $EXIT_OPTS \
+    "
+
+OUTPUT_ARGS=" \
+    --log-interval 1 \
+    --save-interval $SAVE_INTERVAL \
+    --eval-interval 125 \
+    --eval-iters 10 \
+    --tensorboard-dir $TENSORBOARD_PATH \
+    --tensorboard-queue-size 5 \
+    --log-timers-to-tensorboard \
+    --log-batch-size-to-tensorboard \
+    --log-validation-ppl-to-tensorboard \
+    "
+
+ZERO_STAGE=1
+
+config_json="./ds_config.$SLURM_JOBID.json"
+
+# Deepspeed figures out GAS dynamically from dynamic GBS via set_train_batch_size()
+cat <<EOT > $config_json
+{
+  "train_micro_batch_size_per_gpu": $MICRO_BATCH_SIZE,
+  "train_batch_size": $GLOBAL_BATCH_SIZE,
+  "gradient_clipping": 1.0,
+  "zero_optimization": {
+    "stage": $ZERO_STAGE
+  },
+  "fp16": {
+    "enabled": true,
+    "loss_scale": 0,
+    "loss_scale_window": 500,
+    "hysteresis": 2,
+    "min_loss_scale": 1,
+    "initial_scale_power": 12
+  },
+  "steps_per_print": 2000,
+  "wall_clock_breakdown": false
+}
+EOT
+
+
+DEEPSPEED_ARGS=" \
+    --deepspeed \
+    --deepspeed_config ${config_json} \
+    --zero-stage ${ZERO_STAGE} \
+    --deepspeed-activation-checkpointing \
+    "
+
+export LAUNCHER="python -u -m torch.distributed.run \
+    --nproc_per_node $GPUS_PER_NODE \
+    --nnodes $NNODES \
+    --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT \
+    --rdzv_backend c10d \
+    --max_restarts 0 \
+    --tee 3 \
+    "
+
+export CMD=" \
+    `pwd`/finetune_t0.py \
+    --tensor-model-parallel-size $TP_SIZE \
+    --pipeline-model-parallel-size $PP_SIZE \
+    $GPT_ARGS \
+    $OUTPUT_ARGS \
+    --save $CHECKPOINT_PATH \
+    --load $CHECKPOINT_PATH \
+    --train-weighted-split-paths-path $TRAIN_DATA_PATH \
+    --valid-weighted-split-paths-path $VALID_DATA_PATH \
+    --dataloader-type single \
+    --data-impl mmap \
+    --distributed-backend nccl \
+     $DEEPSPEED_ARGS \
+    "
+
+echo $CMD
+
+# do not remove or the training will hang and nodes will be lost w/o this workaround
+export CUDA_LAUNCH_BLOCKING=1
+
+# hide duplicated errors using this hack - will be properly fixed in pt-1.12
+export TORCHELASTIC_ERROR_FILE=/tmp/torch-elastic-error.json
+
+clear; srun --jobid $SLURM_JOBID bash -c "$LAUNCHER --node_rank \$SLURM_PROCID $CMD" 2>&1 | tee -a $LOGS_PATH/main_log.txt
+
+echo "END TIME: $(date)"

train/tr13-mtf/smaller_models/tr13e-350m-mtf-xp3capmixnewcodelonglossseq.slurm

@@ -0,0 +1,211 @@
+#!/bin/bash
+#SBATCH --job-name=xp3capmixnewcodelong
+#SBATCH --qos=qos_gpu-t3
+#SBATCH --nodes=8
+#SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
+#SBATCH --cpus-per-task=40           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --gres=gpu:4                 # number of gpus
+#SBATCH -C v100-32g
+#SBATCH --time 20:00:00             # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --account=six@v100
+
+set -x -e
+
+source $six_ALL_CCFRWORK/start-tr13f-6B3-ml-t0
+echo "START TIME: $(date)"
+
+variant=xp3capmixnewcodelonglossseq
+
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr13e-350M-ml-t0
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints/$variant
+REPO_PATH=$DATA_OUTPUT_PATH/tr13e-350M-ml-logs
+TENSORBOARD_PATH=$REPO_PATH/tensorboard/$variant
+LOGS_PATH=$REPO_PATH/logs/$variant
+mkdir -p $LOGS_PATH
+mkdir -p $TENSORBOARD_PATH
+
+MEGATRON_DEEPSPEED_REPO=/gpfswork/rech/six/commun/code/tr13f-6B3-ml-t0/megdslossseqnew350m/Megatron-DeepSpeed
+cd $MEGATRON_DEEPSPEED_REPO
+
+KILL_SWITCH_PATH=$MEGATRON_DEEPSPEED_REPO/kill-switch-tr13e-350M-mtf
+
+TRAIN_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3capmixnewcodelong_train.txt
+VALID_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3capmixnewcodelong_validation_pretr.txt
+TOKENIZER_NAME_OR_PATH=bigscience/tokenizer
+
+# defining the right environment variables
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+export HF_DATASETS_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+
+# testing for potential faulty nodes
+# srun --jobid $SLURM_JOBID bash -c 'python -c "import torch, socket; print(socket.gethostname(), torch.cuda.is_available())"'
+
+# so processes know who to talk to
+MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)
+MASTER_PORT=6001
+
+GPUS_PER_NODE=4
+NNODES=$SLURM_NNODES
+
+PP_SIZE=1
+TP_SIZE=1
+
+# T0 paper:
+# ...truncate input and target sequences to 1024 and 256 tokens...
+# ...use a batch size of 1024 sequences ... 2^20 total input tokens per batch...
+# We use 2048 total tokens and 512 batch size = 2**20
+MICRO_BATCH_SIZE=1
+GLOBAL_BATCH_SIZE=1024
+
+NLAYERS=24
+NHIDDEN=1024
+NHEADS=16
+SEQ_LEN=2048
+# 250
+SAVE_INTERVAL=2
+
+TRAIN_SAMPLES=6_348_800
+
+# T0 paper:
+# "...we use a learning rate of 1e-3..."
+# However, they use Adafactor, which adapts the LR
+# For Adam we likely want a lower one
+# FLAN:
+# "...decay of 1e-4..""
+
+# Uncomment for the first step
+# --no-load-optim \
+# --reset-progress \
+OPTIMIZER_ARGS=" \
+    --optimizer adam \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.95 \
+    --adam-eps 1e-8 \
+    --lr 2e-5 \
+    --lr-decay-style constant \
+    --lr-warmup-samples 0 \
+    --clip-grad 1.0 \
+    --weight-decay 1e-4 \
+    --no-load-optim \
+    --reset-progress \
+    --norm-target-loss \
+    "
+# for 20h 1190, for 100h 5990
+#    --exit-duration-in-mins 1190 \
+EXIT_OPTS=" \
+    --exit-duration-in-mins 5990 \
+    "
+
+GPT_ARGS=" \
+    --pp-partition-method 'type:transformer|embedding' \
+    --num-layers $NLAYERS \
+    --hidden-size $NHIDDEN \
+    --num-attention-heads $NHEADS \
+    --seq-length $SEQ_LEN \
+    --max-position-embeddings $SEQ_LEN \
+    --micro-batch-size $MICRO_BATCH_SIZE \
+    --global-batch-size $GLOBAL_BATCH_SIZE \
+    --train-samples $TRAIN_SAMPLES \
+    --tokenizer-type PretrainedFromHF \
+    --tokenizer-name-or-path $TOKENIZER_NAME_OR_PATH \
+    --init-method-std 0.0048 \
+    --embed-layernorm \
+    --fp16 \
+    --seed 42 \
+    --position-embedding-type alibi \
+    --checkpoint-activations \
+    --abort-on-unmet-fused-kernel-constraints \
+    --kill-switch-path $KILL_SWITCH_PATH \
+    --pad-vocab-size-to 250880 \
+    $OPTIMIZER_ARGS \
+    $EXIT_OPTS \
+    "
+
+OUTPUT_ARGS=" \
+    --log-interval 1 \
+    --save-interval $SAVE_INTERVAL \
+    --eval-interval 125 \
+    --eval-iters 10 \
+    --tensorboard-dir $TENSORBOARD_PATH \
+    --tensorboard-queue-size 5 \
+    --log-timers-to-tensorboard \
+    --log-batch-size-to-tensorboard \
+    --log-validation-ppl-to-tensorboard \
+    "
+
+ZERO_STAGE=1
+
+config_json="./ds_config.$SLURM_JOBID.json"
+
+# Deepspeed figures out GAS dynamically from dynamic GBS via set_train_batch_size()
+cat <<EOT > $config_json
+{
+  "train_micro_batch_size_per_gpu": $MICRO_BATCH_SIZE,
+  "train_batch_size": $GLOBAL_BATCH_SIZE,
+  "gradient_clipping": 1.0,
+  "zero_optimization": {
+    "stage": $ZERO_STAGE
+  },
+  "fp16": {
+    "enabled": true,
+    "loss_scale": 0,
+    "loss_scale_window": 500,
+    "hysteresis": 2,
+    "min_loss_scale": 1,
+    "initial_scale_power": 12
+  },
+  "steps_per_print": 2000,
+  "wall_clock_breakdown": false
+}
+EOT
+
+
+DEEPSPEED_ARGS=" \
+    --deepspeed \
+    --deepspeed_config ${config_json} \
+    --zero-stage ${ZERO_STAGE} \
+    --deepspeed-activation-checkpointing \
+    "
+
+export LAUNCHER="python -u -m torch.distributed.run \
+    --nproc_per_node $GPUS_PER_NODE \
+    --nnodes $NNODES \
+    --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT \
+    --rdzv_backend c10d \
+    --max_restarts 0 \
+    --tee 3 \
+    "
+
+export CMD=" \
+    `pwd`/finetune_t0.py \
+    --tensor-model-parallel-size $TP_SIZE \
+    --pipeline-model-parallel-size $PP_SIZE \
+    $GPT_ARGS \
+    $OUTPUT_ARGS \
+    --save $CHECKPOINT_PATH \
+    --load $CHECKPOINT_PATH \
+    --train-weighted-split-paths-path $TRAIN_DATA_PATH \
+    --valid-weighted-split-paths-path $VALID_DATA_PATH \
+    --dataloader-type single \
+    --data-impl mmap \
+    --distributed-backend nccl \
+     $DEEPSPEED_ARGS \
+    "
+
+echo $CMD
+
+# do not remove or the training will hang and nodes will be lost w/o this workaround
+export CUDA_LAUNCH_BLOCKING=1
+
+# hide duplicated errors using this hack - will be properly fixed in pt-1.12
+export TORCHELASTIC_ERROR_FILE=/tmp/torch-elastic-error.json
+
+clear; srun --jobid $SLURM_JOBID bash -c "$LAUNCHER --node_rank \$SLURM_PROCID $CMD" 2>&1 | tee -a $LOGS_PATH/main_log.txt
+
+echo "END TIME: $(date)"

train/tr13-mtf/smaller_models/tr13e-760m-mtf-xp3capmixnewcodelonglossseq-a100.slurm

@@ -0,0 +1,211 @@
+#!/bin/bash
+#SBATCH --job-name=xp3capmixnewcodelong760m
+#SBATCH --partition=gpu_p5
+#SBATCH --constraint=a100
+#SBATCH --nodes=16
+#SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
+#SBATCH --cpus-per-task=64           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --gres=gpu:8                 # number of gpus
+#SBATCH --time 20:00:00             # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --account=six@a100
+
+
+set -x -e
+
+source $six_ALL_CCFRWORK/start-tr13f-6B3-ml-t0
+echo "START TIME: $(date)"
+
+variant=xp3capmixnewcodelonglossseq
+
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr13d-760M-ml-t0
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints/$variant
+REPO_PATH=$DATA_OUTPUT_PATH/tr13d-760M-ml-logs
+TENSORBOARD_PATH=$REPO_PATH/tensorboard/$variant
+LOGS_PATH=$REPO_PATH/logs/$variant
+mkdir -p $LOGS_PATH
+mkdir -p $TENSORBOARD_PATH
+
+MEGATRON_DEEPSPEED_REPO=/gpfswork/rech/six/commun/code/tr13f-6B3-ml-t0/megdslossseqnew/Megatron-DeepSpeed
+cd $MEGATRON_DEEPSPEED_REPO
+
+KILL_SWITCH_PATH=$MEGATRON_DEEPSPEED_REPO/kill-switch-tr13e-350M-mtf
+
+TRAIN_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3capmixnewcodelong_train.txt
+VALID_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3capmixnewcodelong_validation_pretr.txt
+TOKENIZER_NAME_OR_PATH=bigscience/tokenizer
+
+# defining the right environment variables
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+export HF_DATASETS_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+
+# testing for potential faulty nodes
+# srun --jobid $SLURM_JOBID bash -c 'python -c "import torch, socket; print(socket.gethostname(), torch.cuda.is_available())"'
+
+# so processes know who to talk to
+MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)
+MASTER_PORT=6001
+
+GPUS_PER_NODE=8
+NNODES=$SLURM_NNODES
+
+PP_SIZE=2
+TP_SIZE=1
+
+# T0 paper:
+# ...truncate input and target sequences to 1024 and 256 tokens...
+# ...use a batch size of 1024 sequences ... 2^20 total input tokens per batch...
+# We use 2048 total tokens and 512 batch size = 2**20
+MICRO_BATCH_SIZE=1
+GLOBAL_BATCH_SIZE=1024
+
+NLAYERS=24
+NHIDDEN=1536
+NHEADS=16
+SEQ_LEN=2048
+# 250
+SAVE_INTERVAL=2
+
+TRAIN_SAMPLES=6_348_800
+
+# T0 paper:
+# "...we use a learning rate of 1e-3..."
+# However, they use Adafactor, which adapts the LR
+# For Adam we likely want a lower one
+# FLAN:
+# "...decay of 1e-4..""
+
+# Uncomment for the first step
+# --no-load-optim \
+OPTIMIZER_ARGS=" \
+    --optimizer adam \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.95 \
+    --adam-eps 1e-8 \
+    --lr 2e-5 \
+    --lr-decay-style constant \
+    --lr-warmup-samples 0 \
+    --clip-grad 1.0 \
+    --weight-decay 1e-4 \
+    --no-load-optim \
+    --norm-target-loss \
+    --reset-progress \
+    "
+# for 20h 1190, for 100h 5990
+#    --exit-duration-in-mins 1190 \
+EXIT_OPTS=" \
+    --exit-duration-in-mins 5990 \
+    "
+
+GPT_ARGS=" \
+    --pp-partition-method 'type:transformer|embedding' \
+    --num-layers $NLAYERS \
+    --hidden-size $NHIDDEN \
+    --num-attention-heads $NHEADS \
+    --seq-length $SEQ_LEN \
+    --max-position-embeddings $SEQ_LEN \
+    --micro-batch-size $MICRO_BATCH_SIZE \
+    --global-batch-size $GLOBAL_BATCH_SIZE \
+    --train-samples $TRAIN_SAMPLES \
+    --tokenizer-type PretrainedFromHF \
+    --tokenizer-name-or-path $TOKENIZER_NAME_OR_PATH \
+    --init-method-std 0.0048 \
+    --embed-layernorm \
+    --fp16 \
+    --seed 42 \
+    --position-embedding-type alibi \
+    --checkpoint-activations \
+    --abort-on-unmet-fused-kernel-constraints \
+    --kill-switch-path $KILL_SWITCH_PATH \
+    --pad-vocab-size-to 250880 \
+    $OPTIMIZER_ARGS \
+    $EXIT_OPTS \
+    "
+
+OUTPUT_ARGS=" \
+    --log-interval 1 \
+    --save-interval $SAVE_INTERVAL \
+    --eval-interval 250 \
+    --eval-iters 5 \
+    --tensorboard-dir $TENSORBOARD_PATH \
+    --tensorboard-queue-size 5 \
+    --log-timers-to-tensorboard \
+    --log-batch-size-to-tensorboard \
+    --log-validation-ppl-to-tensorboard \
+    "
+
+ZERO_STAGE=1
+
+config_json="./ds_config.$SLURM_JOBID.json"
+
+# Deepspeed figures out GAS dynamically from dynamic GBS via set_train_batch_size()
+cat <<EOT > $config_json
+{
+  "train_micro_batch_size_per_gpu": $MICRO_BATCH_SIZE,
+  "train_batch_size": $GLOBAL_BATCH_SIZE,
+  "gradient_clipping": 1.0,
+  "zero_optimization": {
+    "stage": $ZERO_STAGE
+  },
+  "fp16": {
+    "enabled": true,
+    "loss_scale": 0,
+    "loss_scale_window": 500,
+    "hysteresis": 2,
+    "min_loss_scale": 1,
+    "initial_scale_power": 12
+  },
+  "steps_per_print": 2000,
+  "wall_clock_breakdown": false
+}
+EOT
+
+
+DEEPSPEED_ARGS=" \
+    --deepspeed \
+    --deepspeed_config ${config_json} \
+    --zero-stage ${ZERO_STAGE} \
+    --deepspeed-activation-checkpointing \
+    "
+
+export LAUNCHER="python -u -m torch.distributed.run \
+    --nproc_per_node $GPUS_PER_NODE \
+    --nnodes $NNODES \
+    --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT \
+    --rdzv_backend c10d \
+    --max_restarts 0 \
+    --tee 3 \
+    "
+
+export CMD=" \
+    `pwd`/finetune_t0.py \
+    --tensor-model-parallel-size $TP_SIZE \
+    --pipeline-model-parallel-size $PP_SIZE \
+    $GPT_ARGS \
+    $OUTPUT_ARGS \
+    --save $CHECKPOINT_PATH \
+    --load $CHECKPOINT_PATH \
+    --train-weighted-split-paths-path $TRAIN_DATA_PATH \
+    --valid-weighted-split-paths-path $VALID_DATA_PATH \
+    --dataloader-type single \
+    --data-impl mmap \
+    --distributed-backend nccl \
+     $DEEPSPEED_ARGS \
+    "
+
+echo $CMD
+
+# do not remove or the training will hang and nodes will be lost w/o this workaround
+export CUDA_LAUNCH_BLOCKING=1
+
+# hide duplicated errors using this hack - will be properly fixed in pt-1.12
+export TORCHELASTIC_ERROR_FILE=/tmp/torch-elastic-error.json
+
+clear; srun --jobid $SLURM_JOBID bash -c "$LAUNCHER --node_rank \$SLURM_PROCID $CMD" 2>&1 | tee -a $LOGS_PATH/main_log.txt
+
+echo "END TIME: $(date)"

train/tr13-mtf/smaller_models/tr13e-760m-mtf-xp3capmixnewcodelonglossseq.slurm

@@ -0,0 +1,211 @@
+#!/bin/bash
+#SBATCH --job-name=xp3capmixnewcodelong760m
+#SBATCH --qos=qos_gpu-t3
+#SBATCH --nodes=8
+#SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
+#SBATCH --cpus-per-task=40           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --gres=gpu:4                 # number of gpus
+#SBATCH -C v100-32g
+#SBATCH --time 20:00:00             # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --account=six@v100
+
+set -x -e
+
+source $six_ALL_CCFRWORK/start-tr13f-6B3-ml-t0
+echo "START TIME: $(date)"
+
+variant=xp3capmixnewcodelonglossseq
+
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr13d-760M-ml-t0
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints/$variant
+REPO_PATH=$DATA_OUTPUT_PATH/tr13d-760M-ml-logs
+TENSORBOARD_PATH=$REPO_PATH/tensorboard/$variant
+LOGS_PATH=$REPO_PATH/logs/$variant
+mkdir -p $LOGS_PATH
+mkdir -p $TENSORBOARD_PATH
+
+MEGATRON_DEEPSPEED_REPO=/gpfswork/rech/six/commun/code/tr13f-6B3-ml-t0/megdslossseqnew/Megatron-DeepSpeed
+cd $MEGATRON_DEEPSPEED_REPO
+
+KILL_SWITCH_PATH=$MEGATRON_DEEPSPEED_REPO/kill-switch-tr13e-350M-mtf
+
+TRAIN_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3capmixnewcodelong_train.txt
+VALID_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3capmixnewcodelong_validation_pretr.txt
+TOKENIZER_NAME_OR_PATH=bigscience/tokenizer
+
+# defining the right environment variables
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+export HF_DATASETS_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+
+# testing for potential faulty nodes
+# srun --jobid $SLURM_JOBID bash -c 'python -c "import torch, socket; print(socket.gethostname(), torch.cuda.is_available())"'
+
+# so processes know who to talk to
+MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)
+MASTER_PORT=6001
+
+GPUS_PER_NODE=4
+NNODES=$SLURM_NNODES
+
+PP_SIZE=2
+TP_SIZE=1
+
+# T0 paper:
+# ...truncate input and target sequences to 1024 and 256 tokens...
+# ...use a batch size of 1024 sequences ... 2^20 total input tokens per batch...
+# We use 2048 total tokens and 512 batch size = 2**20
+MICRO_BATCH_SIZE=1
+GLOBAL_BATCH_SIZE=1024
+
+NLAYERS=24
+NHIDDEN=1536
+NHEADS=16
+SEQ_LEN=2048
+# 250
+SAVE_INTERVAL=2
+
+TRAIN_SAMPLES=6_348_800
+
+# T0 paper:
+# "...we use a learning rate of 1e-3..."
+# However, they use Adafactor, which adapts the LR
+# For Adam we likely want a lower one
+# FLAN:
+# "...decay of 1e-4..""
+
+# Uncomment for the first step
+# --no-load-optim \
+# --reset-progress \
+OPTIMIZER_ARGS=" \
+    --optimizer adam \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.95 \
+    --adam-eps 1e-8 \
+    --lr 2e-5 \
+    --lr-decay-style constant \
+    --lr-warmup-samples 0 \
+    --clip-grad 1.0 \
+    --weight-decay 1e-4 \
+    --no-load-optim \
+    --reset-progress \    
+    --norm-target-loss \
+    "
+# for 20h 1190, for 100h 5990
+#    --exit-duration-in-mins 1190 \
+EXIT_OPTS=" \
+    --exit-duration-in-mins 5990 \
+    "
+
+GPT_ARGS=" \
+    --pp-partition-method 'type:transformer|embedding' \
+    --num-layers $NLAYERS \
+    --hidden-size $NHIDDEN \
+    --num-attention-heads $NHEADS \
+    --seq-length $SEQ_LEN \
+    --max-position-embeddings $SEQ_LEN \
+    --micro-batch-size $MICRO_BATCH_SIZE \
+    --global-batch-size $GLOBAL_BATCH_SIZE \
+    --train-samples $TRAIN_SAMPLES \
+    --tokenizer-type PretrainedFromHF \
+    --tokenizer-name-or-path $TOKENIZER_NAME_OR_PATH \
+    --init-method-std 0.0048 \
+    --embed-layernorm \
+    --fp16 \
+    --seed 42 \
+    --position-embedding-type alibi \
+    --checkpoint-activations \
+    --abort-on-unmet-fused-kernel-constraints \
+    --kill-switch-path $KILL_SWITCH_PATH \
+    --pad-vocab-size-to 250880 \
+    $OPTIMIZER_ARGS \
+    $EXIT_OPTS \
+    "
+
+OUTPUT_ARGS=" \
+    --log-interval 1 \
+    --save-interval $SAVE_INTERVAL \
+    --eval-interval 125 \
+    --eval-iters 10 \
+    --tensorboard-dir $TENSORBOARD_PATH \
+    --tensorboard-queue-size 5 \
+    --log-timers-to-tensorboard \
+    --log-batch-size-to-tensorboard \
+    --log-validation-ppl-to-tensorboard \
+    "
+
+ZERO_STAGE=1
+
+config_json="./ds_config.$SLURM_JOBID.json"
+
+# Deepspeed figures out GAS dynamically from dynamic GBS via set_train_batch_size()
+cat <<EOT > $config_json
+{
+  "train_micro_batch_size_per_gpu": $MICRO_BATCH_SIZE,
+  "train_batch_size": $GLOBAL_BATCH_SIZE,
+  "gradient_clipping": 1.0,
+  "zero_optimization": {
+    "stage": $ZERO_STAGE
+  },
+  "fp16": {
+    "enabled": true,
+    "loss_scale": 0,
+    "loss_scale_window": 500,
+    "hysteresis": 2,
+    "min_loss_scale": 1,
+    "initial_scale_power": 12
+  },
+  "steps_per_print": 2000,
+  "wall_clock_breakdown": false
+}
+EOT
+
+
+DEEPSPEED_ARGS=" \
+    --deepspeed \
+    --deepspeed_config ${config_json} \
+    --zero-stage ${ZERO_STAGE} \
+    --deepspeed-activation-checkpointing \
+    "
+
+export LAUNCHER="python -u -m torch.distributed.run \
+    --nproc_per_node $GPUS_PER_NODE \
+    --nnodes $NNODES \
+    --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT \
+    --rdzv_backend c10d \
+    --max_restarts 0 \
+    --tee 3 \
+    "
+
+export CMD=" \
+    `pwd`/finetune_t0.py \
+    --tensor-model-parallel-size $TP_SIZE \
+    --pipeline-model-parallel-size $PP_SIZE \
+    $GPT_ARGS \
+    $OUTPUT_ARGS \
+    --save $CHECKPOINT_PATH \
+    --load $CHECKPOINT_PATH \
+    --train-weighted-split-paths-path $TRAIN_DATA_PATH \
+    --valid-weighted-split-paths-path $VALID_DATA_PATH \
+    --dataloader-type single \
+    --data-impl mmap \
+    --distributed-backend nccl \
+     $DEEPSPEED_ARGS \
+    "
+
+echo $CMD
+
+# do not remove or the training will hang and nodes will be lost w/o this workaround
+export CUDA_LAUNCH_BLOCKING=1
+
+# hide duplicated errors using this hack - will be properly fixed in pt-1.12
+export TORCHELASTIC_ERROR_FILE=/tmp/torch-elastic-error.json
+
+clear; srun --jobid $SLURM_JOBID bash -c "$LAUNCHER --node_rank \$SLURM_PROCID $CMD" 2>&1 | tee -a $LOGS_PATH/main_log.txt
+
+echo "END TIME: $(date)"

train/tr13-mtf/smaller_models/tr13f-6B3-mtf-eos.slurm

@@ -0,0 +1,209 @@
+#!/bin/bash
+#SBATCH --job-name=eodtr13f-6B3-ml-t0
+#SBATCH --partition=gpu_p5
+#SBATCH --constraint=a100
+#SBATCH --reservation=hug
+#SBATCH --qos=qos_gpu-gc             # up to 100h
+#SBATCH --nodes=8
+#SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
+#SBATCH --cpus-per-task=64           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --gres=gpu:8                 # number of gpus
+#SBATCH --time 100:00:00             # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --account=six@a100
+
+set -x -e
+
+source $six_ALL_CCFRWORK/start-tr13f-6B3-ml-t0
+echo "START TIME: $(date)"
+
+variant=eos
+
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr13f-6B3-ml-t0
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints/$variant
+REPO_PATH=$DATA_OUTPUT_PATH/tr13f-6B3-ml-t0-logs
+TENSORBOARD_PATH=$REPO_PATH/tensorboard/$variant
+LOGS_PATH=$REPO_PATH/logs/$variant
+mkdir -p $LOGS_PATH
+mkdir -p $TENSORBOARD_PATH
+
+MEGATRON_DEEPSPEED_REPO=/gpfswork/rech/six/commun/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed
+cd $MEGATRON_DEEPSPEED_REPO
+
+KILL_SWITCH_PATH=$MEGATRON_DEEPSPEED_REPO/kill-switch-tr13f-6B3-mtf
+
+TRAIN_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/p31eos_train.txt
+VALID_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/p31eos_validation.txt
+TOKENIZER_NAME_OR_PATH=bigscience/tokenizer
+
+# defining the right environment variables
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+export HF_DATASETS_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+
+# testing for potential faulty nodes
+# srun --jobid $SLURM_JOBID bash -c 'python -c "import torch, socket; print(socket.gethostname(), torch.cuda.is_available())"'
+
+# so processes know who to talk to
+MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)
+MASTER_PORT=6001
+
+GPUS_PER_NODE=8
+NNODES=$SLURM_NNODES
+
+PP_SIZE=1
+TP_SIZE=1
+
+# T0 paper:
+# ...truncate input and target sequences to 1024 and 256 tokens...
+# ...use a batch size of 1024 sequences ... 2^20 total input tokens per batch...
+# We use 2048 total tokens and 512 batch size = 2**20
+MICRO_BATCH_SIZE=4
+GLOBAL_BATCH_SIZE=2048
+
+NLAYERS=30
+NHIDDEN=4096
+NHEADS=32
+SEQ_LEN=2048
+
+SAVE_INTERVAL=1000
+
+TRAIN_SAMPLES=6_348_800
+
+# T0 paper:
+# "...we use a learning rate of 1e-3..."
+# However, they use Adafactor, which adapts the LR
+# For Adam we likely want a lower one
+# FLAN:
+# "...decay of 1e-4..""
+
+# Uncomment for the first step
+# --no-load-optim \
+OPTIMIZER_ARGS=" \
+    --optimizer adam \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.95 \
+    --adam-eps 1e-8 \
+    --lr 2e-5 \
+    --lr-decay-style constant \
+    --lr-warmup-samples 0 \
+    --clip-grad 1.0 \
+    --weight-decay 1e-4 \
+    "
+# for 20h 1190, for 100h 5990
+#    --exit-duration-in-mins 1190 \
+EXIT_OPTS=" \
+    --exit-duration-in-mins 5990 \
+    "
+
+GPT_ARGS=" \
+    --pp-partition-method 'type:transformer|embedding' \
+    --num-layers $NLAYERS \
+    --hidden-size $NHIDDEN \
+    --num-attention-heads $NHEADS \
+    --seq-length $SEQ_LEN \
+    --max-position-embeddings $SEQ_LEN \
+    --micro-batch-size $MICRO_BATCH_SIZE \
+    --global-batch-size $GLOBAL_BATCH_SIZE \
+    --train-samples $TRAIN_SAMPLES \
+    --tokenizer-type PretrainedFromHF \
+    --tokenizer-name-or-path $TOKENIZER_NAME_OR_PATH \
+    --init-method-std 0.0048 \
+    --embed-layernorm \
+    --fp16 \
+    --seed 42 \
+    --position-embedding-type alibi \
+    --checkpoint-activations \
+    --abort-on-unmet-fused-kernel-constraints \
+    --kill-switch-path $KILL_SWITCH_PATH \
+    --pad-vocab-size-to 250880 \
+    $OPTIMIZER_ARGS \
+    $EXIT_OPTS \
+    "
+
+OUTPUT_ARGS=" \
+    --log-interval 1 \
+    --save-interval $SAVE_INTERVAL \
+    --eval-interval 250 \
+    --eval-iters 50 \
+    --tensorboard-dir $TENSORBOARD_PATH \
+    --tensorboard-queue-size 5 \
+    --log-timers-to-tensorboard \
+    --log-batch-size-to-tensorboard \
+    --log-validation-ppl-to-tensorboard \
+    "
+
+ZERO_STAGE=1
+
+config_json="./ds_config.$SLURM_JOBID.json"
+
+# Deepspeed figures out GAS dynamically from dynamic GBS via set_train_batch_size()
+cat <<EOT > $config_json
+{
+  "train_micro_batch_size_per_gpu": $MICRO_BATCH_SIZE,
+  "train_batch_size": $GLOBAL_BATCH_SIZE,
+  "gradient_clipping": 1.0,
+  "zero_optimization": {
+    "stage": $ZERO_STAGE
+  },
+  "fp16": {
+    "enabled": true,
+    "loss_scale": 0,
+    "loss_scale_window": 500,
+    "hysteresis": 2,
+    "min_loss_scale": 1,
+    "initial_scale_power": 12
+  },
+  "steps_per_print": 2000,
+  "wall_clock_breakdown": false
+}
+EOT
+
+
+DEEPSPEED_ARGS=" \
+    --deepspeed \
+    --deepspeed_config ${config_json} \
+    --zero-stage ${ZERO_STAGE} \
+    --deepspeed-activation-checkpointing \
+    "
+
+export LAUNCHER="python -u -m torch.distributed.run \
+    --nproc_per_node $GPUS_PER_NODE \
+    --nnodes $NNODES \
+    --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT \
+    --rdzv_backend c10d \
+    --max_restarts 0 \
+    --tee 3 \
+    "
+
+export CMD=" \
+    `pwd`/finetune_t0.py \
+    --tensor-model-parallel-size $TP_SIZE \
+    --pipeline-model-parallel-size $PP_SIZE \
+    $GPT_ARGS \
+    $OUTPUT_ARGS \
+    --save $CHECKPOINT_PATH \
+    --load $CHECKPOINT_PATH \
+    --train-weighted-split-paths-path $TRAIN_DATA_PATH \
+    --valid-weighted-split-paths-path $VALID_DATA_PATH \
+    --dataloader-type single \
+    --data-impl mmap \
+    --distributed-backend nccl \
+     $DEEPSPEED_ARGS \
+    "
+
+echo $CMD
+
+# do not remove or the training will hang and nodes will be lost w/o this workaround
+export CUDA_LAUNCH_BLOCKING=1
+
+# hide duplicated errors using this hack - will be properly fixed in pt-1.12
+export TORCHELASTIC_ERROR_FILE=/tmp/torch-elastic-error.json
+
+clear; srun --jobid $SLURM_JOBID bash -c "$LAUNCHER --node_rank \$SLURM_PROCID $CMD" 2>&1 | tee -a $LOGS_PATH/main_log.txt
+
+echo "END TIME: $(date)"

train/tr13-mtf/smaller_models/tr13f-6b3-mtf-p31.slurm

@@ -0,0 +1,210 @@
+#!/bin/bash
+#SBATCH --job-name=p31tr13f-6B3-ml-t0
+#SBATCH --partition=gpu_p5
+#SBATCH --constraint=a100
+#SBATCH --reservation=hug
+#SBATCH --qos=qos_gpu-gc             # up to 100h
+#SBATCH --nodes=8
+#SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
+#SBATCH --cpus-per-task=64           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --gres=gpu:8                 # number of gpus
+#SBATCH --time 100:00:00             # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --account=six@a100
+
+set -x -e
+
+source $six_ALL_CCFRWORK/start-tr13f-6B3-ml-t0
+echo "START TIME: $(date)"
+
+variant=p31
+
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr13f-6B3-ml-t0
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints/$variant
+REPO_PATH=$DATA_OUTPUT_PATH/tr13f-6B3-ml-t0-logs
+TENSORBOARD_PATH=$REPO_PATH/tensorboard/$variant
+LOGS_PATH=$REPO_PATH/logs/$variant
+mkdir -p $LOGS_PATH
+mkdir -p $TENSORBOARD_PATH
+
+MEGATRON_DEEPSPEED_REPO=/gpfswork/rech/six/commun/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed
+cd $MEGATRON_DEEPSPEED_REPO
+
+KILL_SWITCH_PATH=$MEGATRON_DEEPSPEED_REPO/kill-switch-tr13f-6B3-mtf
+
+TRAIN_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/p31_train.txt
+VALID_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/p31_validation.txt
+TOKENIZER_NAME_OR_PATH=bigscience/tokenizer
+
+# defining the right environment variables
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+export HF_DATASETS_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+
+# testing for potential faulty nodes
+# srun --jobid $SLURM_JOBID bash -c 'python -c "import torch, socket; print(socket.gethostname(), torch.cuda.is_available())"'
+
+# so processes know who to talk to
+MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)
+MASTER_PORT=6001
+
+GPUS_PER_NODE=8
+NNODES=$SLURM_NNODES
+
+PP_SIZE=1
+TP_SIZE=1
+
+# T0 paper:
+# ...truncate input and target sequences to 1024 and 256 tokens...
+# ...use a batch size of 1024 sequences ... 2^20 total input tokens per batch...
+# We use 2048 total tokens and 512 batch size = 2**20
+MICRO_BATCH_SIZE=4
+GLOBAL_BATCH_SIZE=2048
+
+NLAYERS=30
+NHIDDEN=4096
+NHEADS=32
+SEQ_LEN=2048
+
+SAVE_INTERVAL=500
+
+TRAIN_SAMPLES=6_348_800
+
+# T0 paper:
+# "...we use a learning rate of 1e-3..."
+# However, they use Adafactor, which adapts the LR
+# For Adam we likely want a lower one
+# FLAN:
+# "...decay of 1e-4..""
+
+# Uncomment for the first step
+# --no-load-optim \
+OPTIMIZER_ARGS=" \
+    --optimizer adam \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.95 \
+    --adam-eps 1e-8 \
+    --lr 2e-5 \
+    --lr-decay-style constant \
+    --lr-warmup-samples 0 \
+    --clip-grad 1.0 \
+    --weight-decay 1e-4 \
+    --no-load-optim \
+    "
+# for 20h 1190, for 100h 5990
+#    --exit-duration-in-mins 1190 \
+EXIT_OPTS=" \
+    --exit-duration-in-mins 5990 \
+    "
+
+GPT_ARGS=" \
+    --pp-partition-method 'type:transformer|embedding' \
+    --num-layers $NLAYERS \
+    --hidden-size $NHIDDEN \
+    --num-attention-heads $NHEADS \
+    --seq-length $SEQ_LEN \
+    --max-position-embeddings $SEQ_LEN \
+    --micro-batch-size $MICRO_BATCH_SIZE \
+    --global-batch-size $GLOBAL_BATCH_SIZE \
+    --train-samples $TRAIN_SAMPLES \
+    --tokenizer-type PretrainedFromHF \
+    --tokenizer-name-or-path $TOKENIZER_NAME_OR_PATH \
+    --init-method-std 0.0048 \
+    --embed-layernorm \
+    --fp16 \
+    --seed 42 \
+    --position-embedding-type alibi \
+    --checkpoint-activations \
+    --abort-on-unmet-fused-kernel-constraints \
+    --kill-switch-path $KILL_SWITCH_PATH \
+    --pad-vocab-size-to 250880 \
+    $OPTIMIZER_ARGS \
+    $EXIT_OPTS \
+    "
+
+OUTPUT_ARGS=" \
+    --log-interval 1 \
+    --save-interval $SAVE_INTERVAL \
+    --eval-interval 250 \
+    --eval-iters 50 \
+    --tensorboard-dir $TENSORBOARD_PATH \
+    --tensorboard-queue-size 5 \
+    --log-timers-to-tensorboard \
+    --log-batch-size-to-tensorboard \
+    --log-validation-ppl-to-tensorboard \
+    "
+
+ZERO_STAGE=1
+
+config_json="./ds_config.$SLURM_JOBID.json"
+
+# Deepspeed figures out GAS dynamically from dynamic GBS via set_train_batch_size()
+cat <<EOT > $config_json
+{
+  "train_micro_batch_size_per_gpu": $MICRO_BATCH_SIZE,
+  "train_batch_size": $GLOBAL_BATCH_SIZE,
+  "gradient_clipping": 1.0,
+  "zero_optimization": {
+    "stage": $ZERO_STAGE
+  },
+  "fp16": {
+    "enabled": true,
+    "loss_scale": 0,
+    "loss_scale_window": 500,
+    "hysteresis": 2,
+    "min_loss_scale": 1,
+    "initial_scale_power": 12
+  },
+  "steps_per_print": 2000,
+  "wall_clock_breakdown": false
+}
+EOT
+
+
+DEEPSPEED_ARGS=" \
+    --deepspeed \
+    --deepspeed_config ${config_json} \
+    --zero-stage ${ZERO_STAGE} \
+    --deepspeed-activation-checkpointing \
+    "
+
+export LAUNCHER="python -u -m torch.distributed.run \
+    --nproc_per_node $GPUS_PER_NODE \
+    --nnodes $NNODES \
+    --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT \
+    --rdzv_backend c10d \
+    --max_restarts 0 \
+    --tee 3 \
+    "
+
+export CMD=" \
+    `pwd`/finetune_t0.py \
+    --tensor-model-parallel-size $TP_SIZE \
+    --pipeline-model-parallel-size $PP_SIZE \
+    $GPT_ARGS \
+    $OUTPUT_ARGS \
+    --save $CHECKPOINT_PATH \
+    --load $CHECKPOINT_PATH \
+    --train-weighted-split-paths-path $TRAIN_DATA_PATH \
+    --valid-weighted-split-paths-path $VALID_DATA_PATH \
+    --dataloader-type single \
+    --data-impl mmap \
+    --distributed-backend nccl \
+     $DEEPSPEED_ARGS \
+    "
+
+echo $CMD
+
+# do not remove or the training will hang and nodes will be lost w/o this workaround
+export CUDA_LAUNCH_BLOCKING=1
+
+# hide duplicated errors using this hack - will be properly fixed in pt-1.12
+export TORCHELASTIC_ERROR_FILE=/tmp/torch-elastic-error.json
+
+clear; srun --jobid $SLURM_JOBID bash -c "$LAUNCHER --node_rank \$SLURM_PROCID $CMD" 2>&1 | tee -a $LOGS_PATH/main_log.txt
+
+echo "END TIME: $(date)"

train/tr13-mtf/smaller_models/tr13f-6b3-mtf-xp3capmix.slurm

@@ -0,0 +1,210 @@
+#!/bin/bash
+#SBATCH --job-name=xp3mixedtr13f-6B3-ml-t0
+#SBATCH --partition=gpu_p5
+#SBATCH --constraint=a100
+#SBATCH --reservation=hug
+#SBATCH --qos=qos_gpu-gc             # up to 100h
+#SBATCH --nodes=8
+#SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
+#SBATCH --cpus-per-task=64           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --gres=gpu:8                 # number of gpus
+#SBATCH --time 100:00:00             # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --account=six@a100
+
+set -x -e
+
+source $six_ALL_CCFRWORK/start-tr13f-6B3-ml-t0
+echo "START TIME: $(date)"
+
+variant=xp3capmix
+
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr13f-6B3-ml-t0
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints/$variant
+REPO_PATH=$DATA_OUTPUT_PATH/tr13f-6B3-ml-t0-logs
+TENSORBOARD_PATH=$REPO_PATH/tensorboard/$variant
+LOGS_PATH=$REPO_PATH/logs/$variant
+mkdir -p $LOGS_PATH
+mkdir -p $TENSORBOARD_PATH
+
+MEGATRON_DEEPSPEED_REPO=/gpfswork/rech/six/commun/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed
+cd $MEGATRON_DEEPSPEED_REPO
+
+KILL_SWITCH_PATH=$MEGATRON_DEEPSPEED_REPO/kill-switch-tr13f-6B3-mtf
+
+TRAIN_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3capmix_train.txt
+VALID_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3capmix_validation.txt
+TOKENIZER_NAME_OR_PATH=bigscience/tokenizer
+
+# defining the right environment variables
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+export HF_DATASETS_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+
+# testing for potential faulty nodes
+# srun --jobid $SLURM_JOBID bash -c 'python -c "import torch, socket; print(socket.gethostname(), torch.cuda.is_available())"'
+
+# so processes know who to talk to
+MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)
+MASTER_PORT=6001
+
+GPUS_PER_NODE=8
+NNODES=$SLURM_NNODES
+
+PP_SIZE=1
+TP_SIZE=1
+
+# T0 paper:
+# ...truncate input and target sequences to 1024 and 256 tokens...
+# ...use a batch size of 1024 sequences ... 2^20 total input tokens per batch...
+# We use 2048 total tokens and 512 batch size = 2**20
+MICRO_BATCH_SIZE=4
+GLOBAL_BATCH_SIZE=2048
+
+NLAYERS=30
+NHIDDEN=4096
+NHEADS=32
+SEQ_LEN=2048
+
+SAVE_INTERVAL=250
+
+TRAIN_SAMPLES=6_348_800
+
+# T0 paper:
+# "...we use a learning rate of 1e-3..."
+# However, they use Adafactor, which adapts the LR
+# For Adam we likely want a lower one
+# FLAN:
+# "...decay of 1e-4..""
+
+# Uncomment for the first step
+# --no-load-optim \
+OPTIMIZER_ARGS=" \
+    --optimizer adam \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.95 \
+    --adam-eps 1e-8 \
+    --lr 2e-5 \
+    --lr-decay-style constant \
+    --lr-warmup-samples 0 \
+    --clip-grad 1.0 \
+    --weight-decay 1e-4 \
+    --no-load-optim \
+    "
+# for 20h 1190, for 100h 5990
+#    --exit-duration-in-mins 1190 \
+EXIT_OPTS=" \
+    --exit-duration-in-mins 5990 \
+    "
+
+GPT_ARGS=" \
+    --pp-partition-method 'type:transformer|embedding' \
+    --num-layers $NLAYERS \
+    --hidden-size $NHIDDEN \
+    --num-attention-heads $NHEADS \
+    --seq-length $SEQ_LEN \
+    --max-position-embeddings $SEQ_LEN \
+    --micro-batch-size $MICRO_BATCH_SIZE \
+    --global-batch-size $GLOBAL_BATCH_SIZE \
+    --train-samples $TRAIN_SAMPLES \
+    --tokenizer-type PretrainedFromHF \
+    --tokenizer-name-or-path $TOKENIZER_NAME_OR_PATH \
+    --init-method-std 0.0048 \
+    --embed-layernorm \
+    --fp16 \
+    --seed 42 \
+    --position-embedding-type alibi \
+    --checkpoint-activations \
+    --abort-on-unmet-fused-kernel-constraints \
+    --kill-switch-path $KILL_SWITCH_PATH \
+    --pad-vocab-size-to 250880 \
+    $OPTIMIZER_ARGS \
+    $EXIT_OPTS \
+    "
+
+OUTPUT_ARGS=" \
+    --log-interval 1 \
+    --save-interval $SAVE_INTERVAL \
+    --eval-interval 250 \
+    --eval-iters 50 \
+    --tensorboard-dir $TENSORBOARD_PATH \
+    --tensorboard-queue-size 5 \
+    --log-timers-to-tensorboard \
+    --log-batch-size-to-tensorboard \
+    --log-validation-ppl-to-tensorboard \
+    "
+
+ZERO_STAGE=1
+
+config_json="./ds_config.$SLURM_JOBID.json"
+
+# Deepspeed figures out GAS dynamically from dynamic GBS via set_train_batch_size()
+cat <<EOT > $config_json
+{
+  "train_micro_batch_size_per_gpu": $MICRO_BATCH_SIZE,
+  "train_batch_size": $GLOBAL_BATCH_SIZE,
+  "gradient_clipping": 1.0,
+  "zero_optimization": {
+    "stage": $ZERO_STAGE
+  },
+  "fp16": {
+    "enabled": true,
+    "loss_scale": 0,
+    "loss_scale_window": 500,
+    "hysteresis": 2,
+    "min_loss_scale": 1,
+    "initial_scale_power": 12
+  },
+  "steps_per_print": 2000,
+  "wall_clock_breakdown": false
+}
+EOT
+
+
+DEEPSPEED_ARGS=" \
+    --deepspeed \
+    --deepspeed_config ${config_json} \
+    --zero-stage ${ZERO_STAGE} \
+    --deepspeed-activation-checkpointing \
+    "
+
+export LAUNCHER="python -u -m torch.distributed.run \
+    --nproc_per_node $GPUS_PER_NODE \
+    --nnodes $NNODES \
+    --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT \
+    --rdzv_backend c10d \
+    --max_restarts 0 \
+    --tee 3 \
+    "
+
+export CMD=" \
+    `pwd`/finetune_t0.py \
+    --tensor-model-parallel-size $TP_SIZE \
+    --pipeline-model-parallel-size $PP_SIZE \
+    $GPT_ARGS \
+    $OUTPUT_ARGS \
+    --save $CHECKPOINT_PATH \
+    --load $CHECKPOINT_PATH \
+    --train-weighted-split-paths-path $TRAIN_DATA_PATH \
+    --valid-weighted-split-paths-path $VALID_DATA_PATH \
+    --dataloader-type single \
+    --data-impl mmap \
+    --distributed-backend nccl \
+     $DEEPSPEED_ARGS \
+    "
+
+echo $CMD
+
+# do not remove or the training will hang and nodes will be lost w/o this workaround
+export CUDA_LAUNCH_BLOCKING=1
+
+# hide duplicated errors using this hack - will be properly fixed in pt-1.12
+export TORCHELASTIC_ERROR_FILE=/tmp/torch-elastic-error.json
+
+clear; srun --jobid $SLURM_JOBID bash -c "$LAUNCHER --node_rank \$SLURM_PROCID $CMD" 2>&1 | tee -a $LOGS_PATH/main_log.txt
+
+echo "END TIME: $(date)"

train/tr13-mtf/smaller_models/tr13f-6b3-mtf-xp3capmixfixlong.slurm

@@ -0,0 +1,210 @@
+#!/bin/bash
+#SBATCH --job-name=xp3capmixfixlong
+#SBATCH --partition=gpu_p5
+#SBATCH --constraint=a100
+#SBATCH --reservation=hug
+#SBATCH --qos=qos_gpu-gc             # up to 100h
+#SBATCH --nodes=8
+#SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
+#SBATCH --cpus-per-task=64           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --gres=gpu:8                 # number of gpus
+#SBATCH --time 100:00:00             # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --account=six@a100
+
+set -x -e
+
+source $six_ALL_CCFRWORK/start-tr13f-6B3-ml-t0
+echo "START TIME: $(date)"
+
+variant=xp3capmixfixlong
+
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr13f-6B3-ml-t0
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints/$variant
+REPO_PATH=$DATA_OUTPUT_PATH/tr13f-6B3-ml-t0-logs
+TENSORBOARD_PATH=$REPO_PATH/tensorboard/$variant
+LOGS_PATH=$REPO_PATH/logs/$variant
+mkdir -p $LOGS_PATH
+mkdir -p $TENSORBOARD_PATH
+
+MEGATRON_DEEPSPEED_REPO=/gpfswork/rech/six/commun/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed
+cd $MEGATRON_DEEPSPEED_REPO
+
+KILL_SWITCH_PATH=$MEGATRON_DEEPSPEED_REPO/kill-switch-tr13f-6B3-mtf
+
+TRAIN_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3capmixfixlong_train.txt
+VALID_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3capmixfixlong_validation.txt
+TOKENIZER_NAME_OR_PATH=bigscience/tokenizer
+
+# defining the right environment variables
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+export HF_DATASETS_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+
+# testing for potential faulty nodes
+# srun --jobid $SLURM_JOBID bash -c 'python -c "import torch, socket; print(socket.gethostname(), torch.cuda.is_available())"'
+
+# so processes know who to talk to
+MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)
+MASTER_PORT=6001
+
+GPUS_PER_NODE=8
+NNODES=$SLURM_NNODES
+
+PP_SIZE=1
+TP_SIZE=1
+
+# T0 paper:
+# ...truncate input and target sequences to 1024 and 256 tokens...
+# ...use a batch size of 1024 sequences ... 2^20 total input tokens per batch...
+# We use 2048 total tokens and 512 batch size = 2**20
+MICRO_BATCH_SIZE=4
+GLOBAL_BATCH_SIZE=2048
+
+NLAYERS=30
+NHIDDEN=4096
+NHEADS=32
+SEQ_LEN=2048
+
+SAVE_INTERVAL=2
+
+TRAIN_SAMPLES=6_348_800
+
+# T0 paper:
+# "...we use a learning rate of 1e-3..."
+# However, they use Adafactor, which adapts the LR
+# For Adam we likely want a lower one
+# FLAN:
+# "...decay of 1e-4..""
+
+# Uncomment for the first step
+# --no-load-optim \
+OPTIMIZER_ARGS=" \
+    --optimizer adam \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.95 \
+    --adam-eps 1e-8 \
+    --lr 2e-5 \
+    --lr-decay-style constant \
+    --lr-warmup-samples 0 \
+    --clip-grad 1.0 \
+    --weight-decay 1e-4 \
+    --no-load-optim \
+    "
+# for 20h 1190, for 100h 5990
+#    --exit-duration-in-mins 1190 \
+EXIT_OPTS=" \
+    --exit-duration-in-mins 5990 \
+    "
+
+GPT_ARGS=" \
+    --pp-partition-method 'type:transformer|embedding' \
+    --num-layers $NLAYERS \
+    --hidden-size $NHIDDEN \
+    --num-attention-heads $NHEADS \
+    --seq-length $SEQ_LEN \
+    --max-position-embeddings $SEQ_LEN \
+    --micro-batch-size $MICRO_BATCH_SIZE \
+    --global-batch-size $GLOBAL_BATCH_SIZE \
+    --train-samples $TRAIN_SAMPLES \
+    --tokenizer-type PretrainedFromHF \
+    --tokenizer-name-or-path $TOKENIZER_NAME_OR_PATH \
+    --init-method-std 0.0048 \
+    --embed-layernorm \
+    --fp16 \
+    --seed 42 \
+    --position-embedding-type alibi \
+    --checkpoint-activations \
+    --abort-on-unmet-fused-kernel-constraints \
+    --kill-switch-path $KILL_SWITCH_PATH \
+    --pad-vocab-size-to 250880 \
+    $OPTIMIZER_ARGS \
+    $EXIT_OPTS \
+    "
+
+OUTPUT_ARGS=" \
+    --log-interval 1 \
+    --save-interval $SAVE_INTERVAL \
+    --eval-interval 250 \
+    --eval-iters 50 \
+    --tensorboard-dir $TENSORBOARD_PATH \
+    --tensorboard-queue-size 5 \
+    --log-timers-to-tensorboard \
+    --log-batch-size-to-tensorboard \
+    --log-validation-ppl-to-tensorboard \
+    "
+
+ZERO_STAGE=1
+
+config_json="./ds_config.$SLURM_JOBID.json"
+
+# Deepspeed figures out GAS dynamically from dynamic GBS via set_train_batch_size()
+cat <<EOT > $config_json
+{
+  "train_micro_batch_size_per_gpu": $MICRO_BATCH_SIZE,
+  "train_batch_size": $GLOBAL_BATCH_SIZE,
+  "gradient_clipping": 1.0,
+  "zero_optimization": {
+    "stage": $ZERO_STAGE
+  },
+  "fp16": {
+    "enabled": true,
+    "loss_scale": 0,
+    "loss_scale_window": 500,
+    "hysteresis": 2,
+    "min_loss_scale": 1,
+    "initial_scale_power": 12
+  },
+  "steps_per_print": 2000,
+  "wall_clock_breakdown": false
+}
+EOT
+
+
+DEEPSPEED_ARGS=" \
+    --deepspeed \
+    --deepspeed_config ${config_json} \
+    --zero-stage ${ZERO_STAGE} \
+    --deepspeed-activation-checkpointing \
+    "
+
+export LAUNCHER="python -u -m torch.distributed.run \
+    --nproc_per_node $GPUS_PER_NODE \
+    --nnodes $NNODES \
+    --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT \
+    --rdzv_backend c10d \
+    --max_restarts 0 \
+    --tee 3 \
+    "
+
+export CMD=" \
+    `pwd`/finetune_t0.py \
+    --tensor-model-parallel-size $TP_SIZE \
+    --pipeline-model-parallel-size $PP_SIZE \
+    $GPT_ARGS \
+    $OUTPUT_ARGS \
+    --save $CHECKPOINT_PATH \
+    --load $CHECKPOINT_PATH \
+    --train-weighted-split-paths-path $TRAIN_DATA_PATH \
+    --valid-weighted-split-paths-path $VALID_DATA_PATH \
+    --dataloader-type single \
+    --data-impl mmap \
+    --distributed-backend nccl \
+     $DEEPSPEED_ARGS \
+    "
+
+echo $CMD
+
+# do not remove or the training will hang and nodes will be lost w/o this workaround
+export CUDA_LAUNCH_BLOCKING=1
+
+# hide duplicated errors using this hack - will be properly fixed in pt-1.12
+export TORCHELASTIC_ERROR_FILE=/tmp/torch-elastic-error.json
+
+clear; srun --jobid $SLURM_JOBID bash -c "$LAUNCHER --node_rank \$SLURM_PROCID $CMD" 2>&1 | tee -a $LOGS_PATH/main_log.txt
+
+echo "END TIME: $(date)"

train/tr13-mtf/smaller_models/tr13f-6b3-mtf-xp3capmixfixlonglossseq.slurm

@@ -0,0 +1,211 @@
+#!/bin/bash
+#SBATCH --job-name=xp3capmixfixlonglossseq
+#SBATCH --partition=gpu_p5
+#SBATCH --constraint=a100
+#SBATCH --reservation=hug
+#SBATCH --qos=qos_gpu-gc             # up to 100h
+#SBATCH --nodes=8
+#SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
+#SBATCH --cpus-per-task=64           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --gres=gpu:8                 # number of gpus
+#SBATCH --time 100:00:00             # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --account=six@a100
+
+set -x -e
+
+source $six_ALL_CCFRWORK/start-tr13f-6B3-ml-t0
+echo "START TIME: $(date)"
+
+variant=xp3capmixfixlonglossseq
+
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr13f-6B3-ml-t0
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints/$variant
+REPO_PATH=$DATA_OUTPUT_PATH/tr13f-6B3-ml-t0-logs
+TENSORBOARD_PATH=$REPO_PATH/tensorboard/$variant
+LOGS_PATH=$REPO_PATH/logs/$variant
+mkdir -p $LOGS_PATH
+mkdir -p $TENSORBOARD_PATH
+
+MEGATRON_DEEPSPEED_REPO=/gpfswork/rech/six/commun/code/tr13f-6B3-ml-t0/megdslossseqnew/Megatron-DeepSpeed
+cd $MEGATRON_DEEPSPEED_REPO
+
+KILL_SWITCH_PATH=$MEGATRON_DEEPSPEED_REPO/kill-switch-tr13f-6B3-mtf
+
+TRAIN_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3capmixfixlong_train.txt
+VALID_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3capmixfixlong_validation.txt
+TOKENIZER_NAME_OR_PATH=bigscience/tokenizer
+
+# defining the right environment variables
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+export HF_DATASETS_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+
+# testing for potential faulty nodes
+# srun --jobid $SLURM_JOBID bash -c 'python -c "import torch, socket; print(socket.gethostname(), torch.cuda.is_available())"'
+
+# so processes know who to talk to
+MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)
+MASTER_PORT=6001
+
+GPUS_PER_NODE=8
+NNODES=$SLURM_NNODES
+
+PP_SIZE=1
+TP_SIZE=1
+
+# T0 paper:
+# ...truncate input and target sequences to 1024 and 256 tokens...
+# ...use a batch size of 1024 sequences ... 2^20 total input tokens per batch...
+# We use 2048 total tokens and 512 batch size = 2**20
+MICRO_BATCH_SIZE=4
+GLOBAL_BATCH_SIZE=2048
+
+NLAYERS=30
+NHIDDEN=4096
+NHEADS=32
+SEQ_LEN=2048
+
+SAVE_INTERVAL=2
+
+TRAIN_SAMPLES=6_348_800
+
+# T0 paper:
+# "...we use a learning rate of 1e-3..."
+# However, they use Adafactor, which adapts the LR
+# For Adam we likely want a lower one
+# FLAN:
+# "...decay of 1e-4..""
+
+# Uncomment for the first step
+# --no-load-optim \
+OPTIMIZER_ARGS=" \
+    --optimizer adam \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.95 \
+    --adam-eps 1e-8 \
+    --lr 2e-5 \
+    --lr-decay-style constant \
+    --lr-warmup-samples 0 \
+    --clip-grad 1.0 \
+    --weight-decay 1e-4 \
+    --no-load-optim \
+    --norm-target-loss \
+    "
+# for 20h 1190, for 100h 5990
+#    --exit-duration-in-mins 1190 \
+EXIT_OPTS=" \
+    --exit-duration-in-mins 5990 \
+    "
+
+GPT_ARGS=" \
+    --pp-partition-method 'type:transformer|embedding' \
+    --num-layers $NLAYERS \
+    --hidden-size $NHIDDEN \
+    --num-attention-heads $NHEADS \
+    --seq-length $SEQ_LEN \
+    --max-position-embeddings $SEQ_LEN \
+    --micro-batch-size $MICRO_BATCH_SIZE \
+    --global-batch-size $GLOBAL_BATCH_SIZE \
+    --train-samples $TRAIN_SAMPLES \
+    --tokenizer-type PretrainedFromHF \
+    --tokenizer-name-or-path $TOKENIZER_NAME_OR_PATH \
+    --init-method-std 0.0048 \
+    --embed-layernorm \
+    --fp16 \
+    --seed 42 \
+    --position-embedding-type alibi \
+    --checkpoint-activations \
+    --abort-on-unmet-fused-kernel-constraints \
+    --kill-switch-path $KILL_SWITCH_PATH \
+    --pad-vocab-size-to 250880 \
+    $OPTIMIZER_ARGS \
+    $EXIT_OPTS \
+    "
+
+OUTPUT_ARGS=" \
+    --log-interval 1 \
+    --save-interval $SAVE_INTERVAL \
+    --eval-interval 250 \
+    --eval-iters 50 \
+    --tensorboard-dir $TENSORBOARD_PATH \
+    --tensorboard-queue-size 5 \
+    --log-timers-to-tensorboard \
+    --log-batch-size-to-tensorboard \
+    --log-validation-ppl-to-tensorboard \
+    "
+
+ZERO_STAGE=1
+
+config_json="./ds_config.$SLURM_JOBID.json"
+
+# Deepspeed figures out GAS dynamically from dynamic GBS via set_train_batch_size()
+cat <<EOT > $config_json
+{
+  "train_micro_batch_size_per_gpu": $MICRO_BATCH_SIZE,
+  "train_batch_size": $GLOBAL_BATCH_SIZE,
+  "gradient_clipping": 1.0,
+  "zero_optimization": {
+    "stage": $ZERO_STAGE
+  },
+  "fp16": {
+    "enabled": true,
+    "loss_scale": 0,
+    "loss_scale_window": 500,
+    "hysteresis": 2,
+    "min_loss_scale": 1,
+    "initial_scale_power": 12
+  },
+  "steps_per_print": 2000,
+  "wall_clock_breakdown": false
+}
+EOT
+
+
+DEEPSPEED_ARGS=" \
+    --deepspeed \
+    --deepspeed_config ${config_json} \
+    --zero-stage ${ZERO_STAGE} \
+    --deepspeed-activation-checkpointing \
+    "
+
+export LAUNCHER="python -u -m torch.distributed.run \
+    --nproc_per_node $GPUS_PER_NODE \
+    --nnodes $NNODES \
+    --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT \
+    --rdzv_backend c10d \
+    --max_restarts 0 \
+    --tee 3 \
+    "
+
+export CMD=" \
+    `pwd`/finetune_t0.py \
+    --tensor-model-parallel-size $TP_SIZE \
+    --pipeline-model-parallel-size $PP_SIZE \
+    $GPT_ARGS \
+    $OUTPUT_ARGS \
+    --save $CHECKPOINT_PATH \
+    --load $CHECKPOINT_PATH \
+    --train-weighted-split-paths-path $TRAIN_DATA_PATH \
+    --valid-weighted-split-paths-path $VALID_DATA_PATH \
+    --dataloader-type single \
+    --data-impl mmap \
+    --distributed-backend nccl \
+     $DEEPSPEED_ARGS \
+    "
+
+echo $CMD
+
+# do not remove or the training will hang and nodes will be lost w/o this workaround
+export CUDA_LAUNCH_BLOCKING=1
+
+# hide duplicated errors using this hack - will be properly fixed in pt-1.12
+export TORCHELASTIC_ERROR_FILE=/tmp/torch-elastic-error.json
+
+clear; srun --jobid $SLURM_JOBID bash -c "$LAUNCHER --node_rank \$SLURM_PROCID $CMD" 2>&1 | tee -a $LOGS_PATH/main_log.txt
+
+echo "END TIME: $(date)"

train/tr13-mtf/smaller_models/tr13f-6b3-mtf-xp3capmixfixlonglossseq2.slurm

@@ -0,0 +1,212 @@
+#!/bin/bash
+#SBATCH --job-name=xp3capmixfixlonglossseq2
+#SBATCH --partition=gpu_p5
+#SBATCH --constraint=a100
+#SBATCH --reservation=hug
+#SBATCH --qos=qos_gpu-gc             # up to 100h
+#SBATCH --nodes=8
+#SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
+#SBATCH --cpus-per-task=64           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --gres=gpu:8                 # number of gpus
+#SBATCH --time 100:00:00             # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --account=six@a100
+
+set -x -e
+
+source $six_ALL_CCFRWORK/start-tr13f-6B3-ml-t0
+echo "START TIME: $(date)"
+
+variant=xp3capmixfixlonglossseq2
+
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr13f-6B3-ml-t0
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints/$variant
+REPO_PATH=$DATA_OUTPUT_PATH/tr13f-6B3-ml-t0-logs
+TENSORBOARD_PATH=$REPO_PATH/tensorboard/$variant
+LOGS_PATH=$REPO_PATH/logs/$variant
+mkdir -p $LOGS_PATH
+mkdir -p $TENSORBOARD_PATH
+
+#MEGATRON_DEEPSPEED_REPO=/gpfswork/rech/six/commun/code/tr13f-6B3-ml-t0/megdslossseqnew/Megatron-DeepSpeed
+MEGATRON_DEEPSPEED_REPO=/gpfswork/rech/six/commun/code/tr13f-6B3-ml-t0/megdslossseqnew2/Megatron-DeepSpeed
+cd $MEGATRON_DEEPSPEED_REPO
+
+KILL_SWITCH_PATH=$MEGATRON_DEEPSPEED_REPO/kill-switch-tr13f-6B3-mtf
+
+TRAIN_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3capmixfixlong_train.txt
+VALID_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3capmixfixlong_validation.txt
+TOKENIZER_NAME_OR_PATH=bigscience/tokenizer
+
+# defining the right environment variables
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+export HF_DATASETS_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+
+# testing for potential faulty nodes
+# srun --jobid $SLURM_JOBID bash -c 'python -c "import torch, socket; print(socket.gethostname(), torch.cuda.is_available())"'
+
+# so processes know who to talk to
+MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)
+MASTER_PORT=6001
+
+GPUS_PER_NODE=8
+NNODES=$SLURM_NNODES
+
+PP_SIZE=1
+TP_SIZE=1
+
+# T0 paper:
+# ...truncate input and target sequences to 1024 and 256 tokens...
+# ...use a batch size of 1024 sequences ... 2^20 total input tokens per batch...
+# We use 2048 total tokens and 512 batch size = 2**20
+MICRO_BATCH_SIZE=4
+GLOBAL_BATCH_SIZE=2048
+
+NLAYERS=30
+NHIDDEN=4096
+NHEADS=32
+SEQ_LEN=2048
+
+SAVE_INTERVAL=2
+
+TRAIN_SAMPLES=6_348_800
+
+# T0 paper:
+# "...we use a learning rate of 1e-3..."
+# However, they use Adafactor, which adapts the LR
+# For Adam we likely want a lower one
+# FLAN:
+# "...decay of 1e-4..""
+
+# Uncomment for the first step
+# --no-load-optim \
+OPTIMIZER_ARGS=" \
+    --optimizer adam \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.95 \
+    --adam-eps 1e-8 \
+    --lr 2e-5 \
+    --lr-decay-style constant \
+    --lr-warmup-samples 0 \
+    --clip-grad 1.0 \
+    --weight-decay 1e-4 \
+    --no-load-optim \
+    --norm-target-loss \
+    "
+# for 20h 1190, for 100h 5990
+#    --exit-duration-in-mins 1190 \
+EXIT_OPTS=" \
+    --exit-duration-in-mins 5990 \
+    "
+
+GPT_ARGS=" \
+    --pp-partition-method 'type:transformer|embedding' \
+    --num-layers $NLAYERS \
+    --hidden-size $NHIDDEN \
+    --num-attention-heads $NHEADS \
+    --seq-length $SEQ_LEN \
+    --max-position-embeddings $SEQ_LEN \
+    --micro-batch-size $MICRO_BATCH_SIZE \
+    --global-batch-size $GLOBAL_BATCH_SIZE \
+    --train-samples $TRAIN_SAMPLES \
+    --tokenizer-type PretrainedFromHF \
+    --tokenizer-name-or-path $TOKENIZER_NAME_OR_PATH \
+    --init-method-std 0.0048 \
+    --embed-layernorm \
+    --fp16 \
+    --seed 42 \
+    --position-embedding-type alibi \
+    --checkpoint-activations \
+    --abort-on-unmet-fused-kernel-constraints \
+    --kill-switch-path $KILL_SWITCH_PATH \
+    --pad-vocab-size-to 250880 \
+    $OPTIMIZER_ARGS \
+    $EXIT_OPTS \
+    "
+
+OUTPUT_ARGS=" \
+    --log-interval 1 \
+    --save-interval $SAVE_INTERVAL \
+    --eval-interval 250 \
+    --eval-iters 50 \
+    --tensorboard-dir $TENSORBOARD_PATH \
+    --tensorboard-queue-size 5 \
+    --log-timers-to-tensorboard \
+    --log-batch-size-to-tensorboard \
+    --log-validation-ppl-to-tensorboard \
+    "
+
+ZERO_STAGE=1
+
+config_json="./ds_config.$SLURM_JOBID.json"
+
+# Deepspeed figures out GAS dynamically from dynamic GBS via set_train_batch_size()
+cat <<EOT > $config_json
+{
+  "train_micro_batch_size_per_gpu": $MICRO_BATCH_SIZE,
+  "train_batch_size": $GLOBAL_BATCH_SIZE,
+  "gradient_clipping": 1.0,
+  "zero_optimization": {
+    "stage": $ZERO_STAGE
+  },
+  "fp16": {
+    "enabled": true,
+    "loss_scale": 0,
+    "loss_scale_window": 500,
+    "hysteresis": 2,
+    "min_loss_scale": 1,
+    "initial_scale_power": 12
+  },
+  "steps_per_print": 2000,
+  "wall_clock_breakdown": false
+}
+EOT
+
+
+DEEPSPEED_ARGS=" \
+    --deepspeed \
+    --deepspeed_config ${config_json} \
+    --zero-stage ${ZERO_STAGE} \
+    --deepspeed-activation-checkpointing \
+    "
+
+export LAUNCHER="python -u -m torch.distributed.run \
+    --nproc_per_node $GPUS_PER_NODE \
+    --nnodes $NNODES \
+    --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT \
+    --rdzv_backend c10d \
+    --max_restarts 0 \
+    --tee 3 \
+    "
+
+export CMD=" \
+    `pwd`/finetune_t0.py \
+    --tensor-model-parallel-size $TP_SIZE \
+    --pipeline-model-parallel-size $PP_SIZE \
+    $GPT_ARGS \
+    $OUTPUT_ARGS \
+    --save $CHECKPOINT_PATH \
+    --load $CHECKPOINT_PATH \
+    --train-weighted-split-paths-path $TRAIN_DATA_PATH \
+    --valid-weighted-split-paths-path $VALID_DATA_PATH \
+    --dataloader-type single \
+    --data-impl mmap \
+    --distributed-backend nccl \
+     $DEEPSPEED_ARGS \
+    "
+
+echo $CMD
+
+# do not remove or the training will hang and nodes will be lost w/o this workaround
+export CUDA_LAUNCH_BLOCKING=1
+
+# hide duplicated errors using this hack - will be properly fixed in pt-1.12
+export TORCHELASTIC_ERROR_FILE=/tmp/torch-elastic-error.json
+
+clear; srun --jobid $SLURM_JOBID bash -c "$LAUNCHER --node_rank \$SLURM_PROCID $CMD" 2>&1 | tee -a $LOGS_PATH/main_log.txt
+
+echo "END TIME: $(date)"

train/tr13-mtf/smaller_models/tr13f-6b3-mtf-xp3capmixlonglossseq.slurm

@@ -0,0 +1,211 @@
+#!/bin/bash
+#SBATCH --job-name=xp3capmixlonglossseq
+#SBATCH --partition=gpu_p5
+#SBATCH --constraint=a100
+#SBATCH --reservation=hug
+#SBATCH --qos=qos_gpu-gc             # up to 100h
+#SBATCH --nodes=8
+#SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
+#SBATCH --cpus-per-task=64           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --gres=gpu:8                 # number of gpus
+#SBATCH --time 100:00:00             # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --account=six@a100
+
+set -x -e
+
+source $six_ALL_CCFRWORK/start-tr13f-6B3-ml-t0
+echo "START TIME: $(date)"
+
+variant=xp3capmixlonglossseq
+
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr13f-6B3-ml-t0
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints/$variant
+REPO_PATH=$DATA_OUTPUT_PATH/tr13f-6B3-ml-t0-logs
+TENSORBOARD_PATH=$REPO_PATH/tensorboard/$variant
+LOGS_PATH=$REPO_PATH/logs/$variant
+mkdir -p $LOGS_PATH
+mkdir -p $TENSORBOARD_PATH
+
+MEGATRON_DEEPSPEED_REPO=/gpfswork/rech/six/commun/code/tr13f-6B3-ml-t0/megdslossseqnew/Megatron-DeepSpeed
+cd $MEGATRON_DEEPSPEED_REPO
+
+KILL_SWITCH_PATH=$MEGATRON_DEEPSPEED_REPO/kill-switch-tr13f-6B3-mtf
+
+TRAIN_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3capmixlong_train.txt
+VALID_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3capmixlong_validation.txt
+TOKENIZER_NAME_OR_PATH=bigscience/tokenizer
+
+# defining the right environment variables
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+export HF_DATASETS_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+
+# testing for potential faulty nodes
+# srun --jobid $SLURM_JOBID bash -c 'python -c "import torch, socket; print(socket.gethostname(), torch.cuda.is_available())"'
+
+# so processes know who to talk to
+MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)
+MASTER_PORT=6001
+
+GPUS_PER_NODE=8
+NNODES=$SLURM_NNODES
+
+PP_SIZE=1
+TP_SIZE=1
+
+# T0 paper:
+# ...truncate input and target sequences to 1024 and 256 tokens...
+# ...use a batch size of 1024 sequences ... 2^20 total input tokens per batch...
+# We use 2048 total tokens and 512 batch size = 2**20
+MICRO_BATCH_SIZE=4
+GLOBAL_BATCH_SIZE=2048
+
+NLAYERS=30
+NHIDDEN=4096
+NHEADS=32
+SEQ_LEN=2048
+
+SAVE_INTERVAL=2
+
+TRAIN_SAMPLES=6_348_800
+
+# T0 paper:
+# "...we use a learning rate of 1e-3..."
+# However, they use Adafactor, which adapts the LR
+# For Adam we likely want a lower one
+# FLAN:
+# "...decay of 1e-4..""
+
+# Uncomment for the first step
+# --no-load-optim \
+OPTIMIZER_ARGS=" \
+    --optimizer adam \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.95 \
+    --adam-eps 1e-8 \
+    --lr 2e-5 \
+    --lr-decay-style constant \
+    --lr-warmup-samples 0 \
+    --clip-grad 1.0 \
+    --weight-decay 1e-4 \
+    --no-load-optim \
+    --norm-target-loss \
+    "
+# for 20h 1190, for 100h 5990
+#    --exit-duration-in-mins 1190 \
+EXIT_OPTS=" \
+    --exit-duration-in-mins 5990 \
+    "
+
+GPT_ARGS=" \
+    --pp-partition-method 'type:transformer|embedding' \
+    --num-layers $NLAYERS \
+    --hidden-size $NHIDDEN \
+    --num-attention-heads $NHEADS \
+    --seq-length $SEQ_LEN \
+    --max-position-embeddings $SEQ_LEN \
+    --micro-batch-size $MICRO_BATCH_SIZE \
+    --global-batch-size $GLOBAL_BATCH_SIZE \
+    --train-samples $TRAIN_SAMPLES \
+    --tokenizer-type PretrainedFromHF \
+    --tokenizer-name-or-path $TOKENIZER_NAME_OR_PATH \
+    --init-method-std 0.0048 \
+    --embed-layernorm \
+    --fp16 \
+    --seed 42 \
+    --position-embedding-type alibi \
+    --checkpoint-activations \
+    --abort-on-unmet-fused-kernel-constraints \
+    --kill-switch-path $KILL_SWITCH_PATH \
+    --pad-vocab-size-to 250880 \
+    $OPTIMIZER_ARGS \
+    $EXIT_OPTS \
+    "
+
+OUTPUT_ARGS=" \
+    --log-interval 1 \
+    --save-interval $SAVE_INTERVAL \
+    --eval-interval 250 \
+    --eval-iters 50 \
+    --tensorboard-dir $TENSORBOARD_PATH \
+    --tensorboard-queue-size 5 \
+    --log-timers-to-tensorboard \
+    --log-batch-size-to-tensorboard \
+    --log-validation-ppl-to-tensorboard \
+    "
+
+ZERO_STAGE=1
+
+config_json="./ds_config.$SLURM_JOBID.json"
+
+# Deepspeed figures out GAS dynamically from dynamic GBS via set_train_batch_size()
+cat <<EOT > $config_json
+{
+  "train_micro_batch_size_per_gpu": $MICRO_BATCH_SIZE,
+  "train_batch_size": $GLOBAL_BATCH_SIZE,
+  "gradient_clipping": 1.0,
+  "zero_optimization": {
+    "stage": $ZERO_STAGE
+  },
+  "fp16": {
+    "enabled": true,
+    "loss_scale": 0,
+    "loss_scale_window": 500,
+    "hysteresis": 2,
+    "min_loss_scale": 1,
+    "initial_scale_power": 12
+  },
+  "steps_per_print": 2000,
+  "wall_clock_breakdown": false
+}
+EOT
+
+
+DEEPSPEED_ARGS=" \
+    --deepspeed \
+    --deepspeed_config ${config_json} \
+    --zero-stage ${ZERO_STAGE} \
+    --deepspeed-activation-checkpointing \
+    "
+
+export LAUNCHER="python -u -m torch.distributed.run \
+    --nproc_per_node $GPUS_PER_NODE \
+    --nnodes $NNODES \
+    --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT \
+    --rdzv_backend c10d \
+    --max_restarts 0 \
+    --tee 3 \
+    "
+
+export CMD=" \
+    `pwd`/finetune_t0.py \
+    --tensor-model-parallel-size $TP_SIZE \
+    --pipeline-model-parallel-size $PP_SIZE \
+    $GPT_ARGS \
+    $OUTPUT_ARGS \
+    --save $CHECKPOINT_PATH \
+    --load $CHECKPOINT_PATH \
+    --train-weighted-split-paths-path $TRAIN_DATA_PATH \
+    --valid-weighted-split-paths-path $VALID_DATA_PATH \
+    --dataloader-type single \
+    --data-impl mmap \
+    --distributed-backend nccl \
+     $DEEPSPEED_ARGS \
+    "
+
+echo $CMD
+
+# do not remove or the training will hang and nodes will be lost w/o this workaround
+export CUDA_LAUNCH_BLOCKING=1
+
+# hide duplicated errors using this hack - will be properly fixed in pt-1.12
+export TORCHELASTIC_ERROR_FILE=/tmp/torch-elastic-error.json
+
+clear; srun --jobid $SLURM_JOBID bash -c "$LAUNCHER --node_rank \$SLURM_PROCID $CMD" 2>&1 | tee -a $LOGS_PATH/main_log.txt
+
+echo "END TIME: $(date)"

train/tr13-mtf/smaller_models/tr13f-6b3-mtf-xp3capmixlossseqeos.slurm

@@ -0,0 +1,211 @@
+#!/bin/bash
+#SBATCH --job-name=xp3capmixlossseqeos
+#SBATCH --partition=gpu_p5
+#SBATCH --constraint=a100
+#SBATCH --reservation=hug
+#SBATCH --qos=qos_gpu-gc             # up to 100h
+#SBATCH --nodes=8
+#SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
+#SBATCH --cpus-per-task=64           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --gres=gpu:8                 # number of gpus
+#SBATCH --time 100:00:00             # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --account=six@a100
+
+set -x -e
+
+source $six_ALL_CCFRWORK/start-tr13f-6B3-ml-t0
+echo "START TIME: $(date)"
+
+variant=xp3capmixlossseqeos
+
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr13f-6B3-ml-t0
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints/$variant
+REPO_PATH=$DATA_OUTPUT_PATH/tr13f-6B3-ml-t0-logs
+TENSORBOARD_PATH=$REPO_PATH/tensorboard/$variant
+LOGS_PATH=$REPO_PATH/logs/$variant
+mkdir -p $LOGS_PATH
+mkdir -p $TENSORBOARD_PATH
+
+MEGATRON_DEEPSPEED_REPO=/gpfswork/rech/six/commun/code/tr13f-6B3-ml-t0/megdslossseqnew/Megatron-DeepSpeed
+cd $MEGATRON_DEEPSPEED_REPO
+
+KILL_SWITCH_PATH=$MEGATRON_DEEPSPEED_REPO/kill-switch-tr13f-6B3-mtf
+
+TRAIN_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3capmixv3eos_train.txt
+VALID_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3capmixv3eos_validation.txt
+TOKENIZER_NAME_OR_PATH=bigscience/tokenizer
+
+# defining the right environment variables
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+export HF_DATASETS_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+
+# testing for potential faulty nodes
+# srun --jobid $SLURM_JOBID bash -c 'python -c "import torch, socket; print(socket.gethostname(), torch.cuda.is_available())"'
+
+# so processes know who to talk to
+MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)
+MASTER_PORT=6001
+
+GPUS_PER_NODE=8
+NNODES=$SLURM_NNODES
+
+PP_SIZE=1
+TP_SIZE=1
+
+# T0 paper:
+# ...truncate input and target sequences to 1024 and 256 tokens...
+# ...use a batch size of 1024 sequences ... 2^20 total input tokens per batch...
+# We use 2048 total tokens and 512 batch size = 2**20
+MICRO_BATCH_SIZE=4
+GLOBAL_BATCH_SIZE=2048
+
+NLAYERS=30
+NHIDDEN=4096
+NHEADS=32
+SEQ_LEN=2048
+
+SAVE_INTERVAL=2
+
+TRAIN_SAMPLES=6_348_800
+
+# T0 paper:
+# "...we use a learning rate of 1e-3..."
+# However, they use Adafactor, which adapts the LR
+# For Adam we likely want a lower one
+# FLAN:
+# "...decay of 1e-4..""
+
+# Uncomment for the first step
+# --no-load-optim \
+OPTIMIZER_ARGS=" \
+    --optimizer adam \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.95 \
+    --adam-eps 1e-8 \
+    --lr 2e-5 \
+    --lr-decay-style constant \
+    --lr-warmup-samples 0 \
+    --clip-grad 1.0 \
+    --weight-decay 1e-4 \
+    --no-load-optim \
+    --norm-target-loss \
+    "
+# for 20h 1190, for 100h 5990
+#    --exit-duration-in-mins 1190 \
+EXIT_OPTS=" \
+    --exit-duration-in-mins 5990 \
+    "
+
+GPT_ARGS=" \
+    --pp-partition-method 'type:transformer|embedding' \
+    --num-layers $NLAYERS \
+    --hidden-size $NHIDDEN \
+    --num-attention-heads $NHEADS \
+    --seq-length $SEQ_LEN \
+    --max-position-embeddings $SEQ_LEN \
+    --micro-batch-size $MICRO_BATCH_SIZE \
+    --global-batch-size $GLOBAL_BATCH_SIZE \
+    --train-samples $TRAIN_SAMPLES \
+    --tokenizer-type PretrainedFromHF \
+    --tokenizer-name-or-path $TOKENIZER_NAME_OR_PATH \
+    --init-method-std 0.0048 \
+    --embed-layernorm \
+    --fp16 \
+    --seed 42 \
+    --position-embedding-type alibi \
+    --checkpoint-activations \
+    --abort-on-unmet-fused-kernel-constraints \
+    --kill-switch-path $KILL_SWITCH_PATH \
+    --pad-vocab-size-to 250880 \
+    $OPTIMIZER_ARGS \
+    $EXIT_OPTS \
+    "
+
+OUTPUT_ARGS=" \
+    --log-interval 1 \
+    --save-interval $SAVE_INTERVAL \
+    --eval-interval 250 \
+    --eval-iters 50 \
+    --tensorboard-dir $TENSORBOARD_PATH \
+    --tensorboard-queue-size 5 \
+    --log-timers-to-tensorboard \
+    --log-batch-size-to-tensorboard \
+    --log-validation-ppl-to-tensorboard \
+    "
+
+ZERO_STAGE=1
+
+config_json="./ds_config.$SLURM_JOBID.json"
+
+# Deepspeed figures out GAS dynamically from dynamic GBS via set_train_batch_size()
+cat <<EOT > $config_json
+{
+  "train_micro_batch_size_per_gpu": $MICRO_BATCH_SIZE,
+  "train_batch_size": $GLOBAL_BATCH_SIZE,
+  "gradient_clipping": 1.0,
+  "zero_optimization": {
+    "stage": $ZERO_STAGE
+  },
+  "fp16": {
+    "enabled": true,
+    "loss_scale": 0,
+    "loss_scale_window": 500,
+    "hysteresis": 2,
+    "min_loss_scale": 1,
+    "initial_scale_power": 12
+  },
+  "steps_per_print": 2000,
+  "wall_clock_breakdown": false
+}
+EOT
+
+
+DEEPSPEED_ARGS=" \
+    --deepspeed \
+    --deepspeed_config ${config_json} \
+    --zero-stage ${ZERO_STAGE} \
+    --deepspeed-activation-checkpointing \
+    "
+
+export LAUNCHER="python -u -m torch.distributed.run \
+    --nproc_per_node $GPUS_PER_NODE \
+    --nnodes $NNODES \
+    --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT \
+    --rdzv_backend c10d \
+    --max_restarts 0 \
+    --tee 3 \
+    "
+
+export CMD=" \
+    `pwd`/finetune_t0.py \
+    --tensor-model-parallel-size $TP_SIZE \
+    --pipeline-model-parallel-size $PP_SIZE \
+    $GPT_ARGS \
+    $OUTPUT_ARGS \
+    --save $CHECKPOINT_PATH \
+    --load $CHECKPOINT_PATH \
+    --train-weighted-split-paths-path $TRAIN_DATA_PATH \
+    --valid-weighted-split-paths-path $VALID_DATA_PATH \
+    --dataloader-type single \
+    --data-impl mmap \
+    --distributed-backend nccl \
+     $DEEPSPEED_ARGS \
+    "
+
+echo $CMD
+
+# do not remove or the training will hang and nodes will be lost w/o this workaround
+export CUDA_LAUNCH_BLOCKING=1
+
+# hide duplicated errors using this hack - will be properly fixed in pt-1.12
+export TORCHELASTIC_ERROR_FILE=/tmp/torch-elastic-error.json
+
+clear; srun --jobid $SLURM_JOBID bash -c "$LAUNCHER --node_rank \$SLURM_PROCID $CMD" 2>&1 | tee -a $LOGS_PATH/main_log.txt
+
+echo "END TIME: $(date)"

train/tr13-mtf/smaller_models/tr13f-6b3-mtf-xp3capmixnewcodelonglossseq-val.slurm

@@ -0,0 +1,212 @@
+#!/bin/bash
+#SBATCH --job-name=valxp3capmixnewcodelong
+#SBATCH --partition=gpu_p5
+#SBATCH --constraint=a100
+#SBATCH --reservation=hug
+#SBATCH --qos=qos_gpu-gc             # up to 100h
+#SBATCH --nodes=8
+#SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
+#SBATCH --cpus-per-task=64           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --gres=gpu:8                 # number of gpus
+#SBATCH --time 10:00:00             # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --account=six@a100
+
+set -x -e
+
+source $six_ALL_CCFRWORK/start-tr13f-6B3-ml-t0
+echo "START TIME: $(date)"
+
+variant=xp3capmixnewcodelonglossseq
+
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr13f-6B3-ml-t0
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints/$variant
+REPO_PATH=$DATA_OUTPUT_PATH/tr13f-6B3-ml-t0-logs
+TENSORBOARD_PATH=$REPO_PATH/tensorboard/$variant
+LOGS_PATH=$REPO_PATH/logs/$variant
+mkdir -p $LOGS_PATH
+mkdir -p $TENSORBOARD_PATH
+
+MEGATRON_DEEPSPEED_REPO=/gpfswork/rech/six/commun/code/tr13f-6B3-ml-t0/megdslossseqnew/Megatron-DeepSpeed
+cd $MEGATRON_DEEPSPEED_REPO
+
+KILL_SWITCH_PATH=$MEGATRON_DEEPSPEED_REPO/kill-switch-tr13f-6B3-mtf
+
+TRAIN_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3capmixnewcodelong_train.txt
+VALID_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3capmixnewcodelong_validation_pretr.txt
+TOKENIZER_NAME_OR_PATH=bigscience/tokenizer
+
+# defining the right environment variables
+export TRANSFORMERS_CACHE=$six_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$six_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$six_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$six_ALL_CCFRWORK/metrics
+export HF_DATASETS_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+
+# testing for potential faulty nodes
+# srun --jobid $SLURM_JOBID bash -c 'python -c "import torch, socket; print(socket.gethostname(), torch.cuda.is_available())"'
+
+# so processes know who to talk to
+MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)
+MASTER_PORT=6001
+
+GPUS_PER_NODE=8
+NNODES=$SLURM_NNODES
+
+PP_SIZE=1
+TP_SIZE=1
+
+# T0 paper:
+# ...truncate input and target sequences to 1024 and 256 tokens...
+# ...use a batch size of 1024 sequences ... 2^20 total input tokens per batch...
+# We use 2048 total tokens and 512 batch size = 2**20
+MICRO_BATCH_SIZE=4
+GLOBAL_BATCH_SIZE=2048
+
+NLAYERS=30
+NHIDDEN=4096
+NHEADS=32
+SEQ_LEN=2048
+# 250
+SAVE_INTERVAL=2
+
+TRAIN_SAMPLES=6_348_800
+
+# T0 paper:
+# "...we use a learning rate of 1e-3..."
+# However, they use Adafactor, which adapts the LR
+# For Adam we likely want a lower one
+# FLAN:
+# "...decay of 1e-4..""
+
+# Uncomment for the first step
+# --no-load-optim \
+OPTIMIZER_ARGS=" \
+    --optimizer adam \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.95 \
+    --adam-eps 1e-8 \
+    --lr 2e-5 \
+    --lr-decay-style constant \
+    --lr-warmup-samples 0 \
+    --clip-grad 1.0 \
+    --weight-decay 1e-4 \
+    --no-load-optim \
+    --norm-target-loss \
+    "
+# for 20h 1190, for 100h 5990
+#    --exit-duration-in-mins 1190 \
+EXIT_OPTS=" \
+    --exit-duration-in-mins 5990 \
+    "
+
+GPT_ARGS=" \
+    --pp-partition-method 'type:transformer|embedding' \
+    --num-layers $NLAYERS \
+    --hidden-size $NHIDDEN \
+    --num-attention-heads $NHEADS \
+    --seq-length $SEQ_LEN \
+    --max-position-embeddings $SEQ_LEN \
+    --micro-batch-size $MICRO_BATCH_SIZE \
+    --global-batch-size $GLOBAL_BATCH_SIZE \
+    --train-samples $TRAIN_SAMPLES \
+    --tokenizer-type PretrainedFromHF \
+    --tokenizer-name-or-path $TOKENIZER_NAME_OR_PATH \
+    --init-method-std 0.0048 \
+    --embed-layernorm \
+    --fp16 \
+    --seed 42 \
+    --position-embedding-type alibi \
+    --checkpoint-activations \
+    --abort-on-unmet-fused-kernel-constraints \
+    --kill-switch-path $KILL_SWITCH_PATH \
+    --pad-vocab-size-to 250880 \
+    $OPTIMIZER_ARGS \
+    $EXIT_OPTS \
+    "
+
+OUTPUT_ARGS=" \
+    --log-interval 1 \
+    --save-interval $SAVE_INTERVAL \
+    --eval-interval 125 \
+    --eval-only True \
+    --eval-iters 10 \
+    --tensorboard-dir $TENSORBOARD_PATH \
+    --tensorboard-queue-size 5 \
+    --log-timers-to-tensorboard \
+    --log-batch-size-to-tensorboard \
+    --log-validation-ppl-to-tensorboard \
+    "
+
+ZERO_STAGE=1
+
+config_json="./ds_config.$SLURM_JOBID.json"
+
+# Deepspeed figures out GAS dynamically from dynamic GBS via set_train_batch_size()
+cat <<EOT > $config_json
+{
+  "train_micro_batch_size_per_gpu": $MICRO_BATCH_SIZE,
+  "train_batch_size": $GLOBAL_BATCH_SIZE,
+  "gradient_clipping": 1.0,
+  "zero_optimization": {
+    "stage": $ZERO_STAGE
+  },
+  "fp16": {
+    "enabled": true,
+    "loss_scale": 0,
+    "loss_scale_window": 500,
+    "hysteresis": 2,
+    "min_loss_scale": 1,
+    "initial_scale_power": 12
+  },
+  "steps_per_print": 2000,
+  "wall_clock_breakdown": false
+}
+EOT
+
+
+DEEPSPEED_ARGS=" \
+    --deepspeed \
+    --deepspeed_config ${config_json} \
+    --zero-stage ${ZERO_STAGE} \
+    --deepspeed-activation-checkpointing \
+    "
+
+export LAUNCHER="python -u -m torch.distributed.run \
+    --nproc_per_node $GPUS_PER_NODE \
+    --nnodes $NNODES \
+    --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT \
+    --rdzv_backend c10d \
+    --max_restarts 0 \
+    --tee 3 \
+    "
+
+export CMD=" \
+    `pwd`/finetune_t0.py \
+    --tensor-model-parallel-size $TP_SIZE \
+    --pipeline-model-parallel-size $PP_SIZE \
+    $GPT_ARGS \
+    $OUTPUT_ARGS \
+    --save $CHECKPOINT_PATH \
+    --load $CHECKPOINT_PATH \
+    --train-weighted-split-paths-path $TRAIN_DATA_PATH \
+    --valid-weighted-split-paths-path $VALID_DATA_PATH \
+    --dataloader-type single \
+    --data-impl mmap \
+    --distributed-backend nccl \
+     $DEEPSPEED_ARGS \
+    "
+
+echo $CMD
+
+# do not remove or the training will hang and nodes will be lost w/o this workaround
+export CUDA_LAUNCH_BLOCKING=1
+
+# hide duplicated errors using this hack - will be properly fixed in pt-1.12
+export TORCHELASTIC_ERROR_FILE=/tmp/torch-elastic-error.json
+
+clear; srun --jobid $SLURM_JOBID bash -c "$LAUNCHER --node_rank \$SLURM_PROCID $CMD" 2>&1 | tee -a $LOGS_PATH/main_log.txt
+
+echo "END TIME: $(date)"