Add files using upload-large-folder tool

evaluation/results/tr11/README.md

@@ -0,0 +1,11 @@
+# BigScience BLOOM Evaluation Results
+
+This folder contains evaluation results of the BLOOM model family.
+
+## Evaluation Procedure
+
+- bslmeval files were created using the below:
+    - https://github.com/bigscience-workshop/Megatron-DeepSpeed/pull/291
+    - https://github.com/bigscience-workshop/lm-evaluation-harness
+- humaneval files were created using the HumanEval code dataset with the below:
+    - https://github.com/loubnabnl/bloom-code-evaluation

evaluation/results/tr11/bloom/humaneval_temp02.json

@@ -0,0 +1 @@
+{"pass@1": 0.15524390243902436, "pass@10": 0.25233297635811675, "pass@100": 0.31325799399147314}

evaluation/results/tr11/bloom/humaneval_temp06.json

@@ -0,0 +1 @@
+{"pass@1": 0.14417682926829267, "pass@10": 0.3220367632383857, "pass@100": 0.5380466541797105}

evaluation/results/tr11/bloom/humaneval_temp08.json

@@ -0,0 +1 @@
+{"pass@1": 0.12228658536585368, "pass@10": 0.30805813658531067, "pass@100": 0.5545431515723145}

evaluation/results/tr11/bloom/mdtable.txt

@@ -0,0 +1,148 @@
+| Task | Language | Metric | BLOOM-176B | OPT-175B* |
+|:--------|:-----------------|:------------------------|-------------:|------------:|
+| arc_challenge | eng | acc ↑ | 0.411 | 0.412 |
+| arc_easy | eng | acc ↑ | 0.726 | 0.751 |
+| axb (Median of 10 prompts) | eng | acc ↑ | 0.575 | 0.532 |
+| axg (Median of 10 prompts) | eng | acc ↑ | 0.525 | 0.548 |
+| boolq (Median of 11 prompts) | eng | acc ↑ | 0.635 | 0.622 |
+| cb (Median of 15 prompts) | eng | acc ↑ | 0.339 | 0.411 |
+| cola (Median of 5 prompts) | eng | acc ↑ | 0.39 | 0.444 |
+| copa (Median of 9 prompts) | eng | acc ↑ | 0.56 | 0.55 |
+| crows_pairs_english (Median of 6 prompts) | eng | acc ↑ | 0.5 | 0.502 |
+| crows_pairs_french (Median of 7 prompts) | fra | acc ↑ | 0.506 | 0.499 |
+| diabla (Median of 2 prompts) | eng | acc ↑ | 0.295 | 0.289 |
+| gsarti/flores_101_afr | afr | byte_perplexity ↓ | 4.254 | 3.381 |
+| gsarti/flores_101_amh | amh | byte_perplexity ↓ | 3.717 | 3.87 |
+| gsarti/flores_101_ara | ara | byte_perplexity ↓ | 1.705 | 2.42 |
+| gsarti/flores_101_asm | asm | byte_perplexity ↓ | 6.577 | 3.028 |
+| gsarti/flores_101_ast | ast | byte_perplexity ↓ | 2.856 | 4.737 |
+| gsarti/flores_101_azj | azj | byte_perplexity ↓ | 4.807 | 4.767 |
+| gsarti/flores_101_bel | bel | byte_perplexity ↓ | 2.731 | 2.557 |
+| gsarti/flores_101_ben | ben | byte_perplexity ↓ | 5.993 | 2.243 |
+| gsarti/flores_101_bos | bos | byte_perplexity ↓ | 3.594 | 2.668 |
+| gsarti/flores_101_bul | bul | byte_perplexity ↓ | 2.159 | 2.099 |
+| gsarti/flores_101_cat | cat | byte_perplexity ↓ | 2.168 | 2.837 |
+| gsarti/flores_101_ceb | ceb | byte_perplexity ↓ | 5.287 | 3.636 |
+| gsarti/flores_101_ces | ces | byte_perplexity ↓ | 3.452 | 2.749 |
+| gsarti/flores_101_ckb | ckb | byte_perplexity ↓ | 3.705 | 4.688 |
+| gsarti/flores_101_cym | cym | byte_perplexity ↓ | 7.089 | 5.075 |
+| gsarti/flores_101_dan | dan | byte_perplexity ↓ | 3.43 | 2.492 |
+| gsarti/flores_101_deu | deu | byte_perplexity ↓ | 2.338 | 2.099 |
+| gsarti/flores_101_ell | ell | byte_perplexity ↓ | 1.96 | 1.811 |
+| gsarti/flores_101_eng | eng | byte_perplexity ↓ | 1.882 | 1.9 |
+| gsarti/flores_101_est | est | byte_perplexity ↓ | 5.774 | 3.533 |
+| gsarti/flores_101_fas | fas | byte_perplexity ↓ | 2.431 | 2.444 |
+| gsarti/flores_101_fin | fin | byte_perplexity ↓ | 4.304 | 2.601 |
+| gsarti/flores_101_fra | fra | byte_perplexity ↓ | 1.937 | 1.984 |
+| gsarti/flores_101_ful | ful | byte_perplexity ↓ | 9.74 | 11.84 |
+| gsarti/flores_101_gle | gle | byte_perplexity ↓ | 6.035 | 3.914 |
+| gsarti/flores_101_glg | glg | byte_perplexity ↓ | 2.365 | 3.015 |
+| gsarti/flores_101_guj | guj | byte_perplexity ↓ | 5.707 | 2.438 |
+| gsarti/flores_101_hau | hau | byte_perplexity ↓ | 8.855 | 5.283 |
+| gsarti/flores_101_heb | heb | byte_perplexity ↓ | 2.921 | 2.903 |
+| gsarti/flores_101_hin | hin | byte_perplexity ↓ | 5.452 | 1.86 |
+| gsarti/flores_101_hrv | hrv | byte_perplexity ↓ | 3.706 | 2.715 |
+| gsarti/flores_101_hun | hun | byte_perplexity ↓ | 4.059 | 2.865 |
+| gsarti/flores_101_hye | hye | byte_perplexity ↓ | 3.127 | 3.411 |
+| gsarti/flores_101_ibo | ibo | byte_perplexity ↓ | 3.95 | 8.008 |
+| gsarti/flores_101_ind | ind | byte_perplexity ↓ | 1.976 | 2.632 |
+| gsarti/flores_101_isl | isl | byte_perplexity ↓ | 5.501 | 4.701 |
+| gsarti/flores_101_ita | ita | byte_perplexity ↓ | 2.314 | 2.104 |
+| gsarti/flores_101_jav | jav | byte_perplexity ↓ | 4.942 | 8.16 |
+| gsarti/flores_101_jpn | jpn | byte_perplexity ↓ | 2.259 | 2.198 |
+| gsarti/flores_101_kam | kam | byte_perplexity ↓ | 9.743 | 10.981 |
+| gsarti/flores_101_kan | kan | byte_perplexity ↓ | 6.234 | 2.373 |
+| gsarti/flores_101_kat | kat | byte_perplexity ↓ | 2.051 | 2.466 |
+| gsarti/flores_101_kaz | kaz | byte_perplexity ↓ | 3.039 | 4.376 |
+| gsarti/flores_101_kea | kea | byte_perplexity ↓ | 7.147 | 9.632 |
+| gsarti/flores_101_khm | khm | byte_perplexity ↓ | 3.367 | 2.646 |
+| gsarti/flores_101_kir | kir | byte_perplexity ↓ | 3.241 | 4.522 |
+| gsarti/flores_101_kor | kor | byte_perplexity ↓ | 2.902 | 3.376 |
+| gsarti/flores_101_lao | lao | byte_perplexity ↓ | 2.331 | 3.106 |
+| gsarti/flores_101_lav | lav | byte_perplexity ↓ | 5.224 | 4.811 |
+| gsarti/flores_101_lin | lin | byte_perplexity ↓ | 4.847 | 8.871 |
+| gsarti/flores_101_lit | lit | byte_perplexity ↓ | 4.543 | 5.183 |
+| gsarti/flores_101_ltz | ltz | byte_perplexity ↓ | 5.591 | 7.158 |
+| gsarti/flores_101_lug | lug | byte_perplexity ↓ | 5.43 | 7.399 |
+| gsarti/flores_101_luo | luo | byte_perplexity ↓ | 12.031 | 11.951 |
+| gsarti/flores_101_mal | mal | byte_perplexity ↓ | 4.794 | 2.054 |
+| gsarti/flores_101_mar | mar | byte_perplexity ↓ | 6.857 | 2.274 |
+| gsarti/flores_101_mkd | mkd | byte_perplexity ↓ | 2.335 | 2.538 |
+| gsarti/flores_101_mlt | mlt | byte_perplexity ↓ | 9.041 | 5.996 |
+| gsarti/flores_101_mon | mon | byte_perplexity ↓ | 3.095 | 4.519 |
+| gsarti/flores_101_mri | mri | byte_perplexity ↓ | 5.266 | 4.438 |
+| gsarti/flores_101_msa | msa | byte_perplexity ↓ | 2.222 | 2.935 |
+| gsarti/flores_101_mya | mya | byte_perplexity ↓ | 2.523 | 2.413 |
+| gsarti/flores_101_nld | nld | byte_perplexity ↓ | 2.799 | 2.293 |
+| gsarti/flores_101_nob | nob | byte_perplexity ↓ | 3.629 | 2.593 |
+| gsarti/flores_101_npi | npi | byte_perplexity ↓ | 6.666 | 2.499 |
+| gsarti/flores_101_nso | nso | byte_perplexity ↓ | 5.015 | 8.485 |
+| gsarti/flores_101_nya | nya | byte_perplexity ↓ | 4.938 | 7.548 |
+| gsarti/flores_101_oci | oci | byte_perplexity ↓ | 3.607 | 4.936 |
+| gsarti/flores_101_orm | orm | byte_perplexity ↓ | 11.316 | 7.145 |
+| gsarti/flores_101_ory | ory | byte_perplexity ↓ | 5.982 | 2.668 |
+| gsarti/flores_101_pan | pan | byte_perplexity ↓ | 4.772 | 2.782 |
+| gsarti/flores_101_pol | pol | byte_perplexity ↓ | 3.012 | 2.432 |
+| gsarti/flores_101_por | por | byte_perplexity ↓ | 1.841 | 2.178 |
+| gsarti/flores_101_pus | pus | byte_perplexity ↓ | 4.624 | 4.785 |
+| gsarti/flores_101_ron | ron | byte_perplexity ↓ | 3.05 | 2.197 |
+| gsarti/flores_101_rus | rus | byte_perplexity ↓ | 1.708 | 1.689 |
+| gsarti/flores_101_slk | slk | byte_perplexity ↓ | 4.038 | 3.419 |
+| gsarti/flores_101_slv | slv | byte_perplexity ↓ | 4.141 | 3.582 |
+| gsarti/flores_101_sna | sna | byte_perplexity ↓ | 4.711 | 5.588 |
+| gsarti/flores_101_snd | snd | byte_perplexity ↓ | 4.206 | 5.667 |
+| gsarti/flores_101_som | som | byte_perplexity ↓ | 9.154 | 4.788 |
+| gsarti/flores_101_spa | spa | byte_perplexity ↓ | 1.796 | 2.098 |
+| gsarti/flores_101_srp | srp | byte_perplexity ↓ | 2.241 | 2.688 |
+| gsarti/flores_101_swe | swe | byte_perplexity ↓ | 3.345 | 2.468 |
+| gsarti/flores_101_swh | swh | byte_perplexity ↓ | 2.684 | 4.473 |
+| gsarti/flores_101_tam | tam | byte_perplexity ↓ | 5.165 | 2.024 |
+| gsarti/flores_101_tel | tel | byte_perplexity ↓ | 6.81 | 2.407 |
+| gsarti/flores_101_tgk | tgk | byte_perplexity ↓ | 3.785 | 4.899 |
+| gsarti/flores_101_tgl | tgl | byte_perplexity ↓ | 3.75 | 2.738 |
+| gsarti/flores_101_tha | tha | byte_perplexity ↓ | 2.104 | 2.035 |
+| gsarti/flores_101_tur | tur | byte_perplexity ↓ | 3.318 | 2.622 |
+| gsarti/flores_101_ukr | ukr | byte_perplexity ↓ | 2.089 | 1.93 |
+| gsarti/flores_101_umb | umb | byte_perplexity ↓ | 11.766 | 11.64 |
+| gsarti/flores_101_urd | urd | byte_perplexity ↓ | 1.779 | 2.982 |
+| gsarti/flores_101_uzb | uzb | byte_perplexity ↓ | 8.5 | 13.209 |
+| gsarti/flores_101_vie | vie | byte_perplexity ↓ | 1.659 | 2.229 |
+| gsarti/flores_101_wol | wol | byte_perplexity ↓ | 6.142 | 13.945 |
+| gsarti/flores_101_xho | xho | byte_perplexity ↓ | 4.69 | 8.42 |
+| gsarti/flores_101_yor | yor | byte_perplexity ↓ | 4.361 | 7.636 |
+| gsarti/flores_101_zho_simpl | zho_simpl | byte_perplexity ↓ | 2.118 | 5.113 |
+| gsarti/flores_101_zho_trad | zho_trad | byte_perplexity ↓ | 2.274 | 5.67 |
+| gsarti/flores_101_zul | zul | byte_perplexity ↓ | 6.017 | 7.341 |
+| headqa | esp | acc ↑ | 0.346 | 0.244 |
+| hellaswag | eng | acc ↑ | 0.535 | 0.592 |
+| lambada_mt_de | deu | acc ↑ | 0.329 | 0.358 |
+| lambada_mt_en | eng | acc ↑ | 0.672 | 0.747 |
+| lambada_mt_es | esp | acc ↑ | 0.476 | 0.397 |
+| lambada_mt_it | ita | acc ↑ | 0.406 | 0.409 |
+| logiqa | eng | acc ↑ | 0.235 | 0.244 |
+| mathqa | eng | acc ↑ | 0.277 | 0.268 |
+| mc_taco | eng | em ↑ | 0.131 | 0.124 |
+| mnli (Median of 15 prompts) | eng | acc ↑ | 0.355 | 0.36 |
+| mnli_mismatched (Median of 15 prompts) | eng | acc ↑ | 0.355 | 0.36 |
+| mrpc | eng | acc ↑ | 0.387 | 0.446 |
+| multirc (Median of 11 prompts) | eng | acc ↑ | 0.571 | 0.599 |
+| openbookqa | eng | acc ↑ | 0.312 | 0.322 |
+| piqa | eng | acc ↑ | 0.781 | 0.791 |
+| prost | eng | acc ↑ | 0.298 | 0.299 |
+| pubmedqa | eng | acc ↑ | 0.741 | 0.709 |
+| qnli | eng | acc ↑ | 0.517 | 0.554 |
+| qqp (Median of 7 prompts) | eng | acc ↑ | 0.588 | 0.395 |
+| race | eng | acc ↑ | 0.39 | 0.402 |
+| rte (Median of 6 prompts) | eng | acc ↑ | 0.52 | 0.495 |
+| sciq | eng | acc ↑ | 0.936 | 0.948 |
+| sst (Median of 6 prompts) | eng | acc ↑ | 0.604 | 0.647 |
+| triviaqa | eng | acc ↑ | 0.183 | 0.342 |
+| tydiqa_primary (Median of 16 prompts) | eng | acc ↑ | 0.281 | 0.148 |
+| webqs | eng | acc ↑ | 0.062 | 0.159 |
+| wic (Median of 11 prompts) | eng | acc ↑ | 0.506 | 0.498 |
+| winogrande | eng | acc ↑ | 0.71 | 0.736 |
+| wnli (Median of 6 prompts) | eng | acc ↑ | 0.57 | 0.563 |
+| wsc (Median of 11 prompts) | eng | acc ↑ | 0.519 | 0.413 |
+| humaneval | python | pass@1 ↑ | 0.155 | 0.0 |
+| humaneval | python | pass@10 ↑ | 0.322 | 0.0 |
+| humaneval | python | pass@100 ↑ | 0.555 | 0.003 |

evaluation/results/tr11/bloom350m/humaneval_temp08.json

@@ -0,0 +1 @@
+{"pass@1": 0.004573170731707317, "pass@10": 0.025074764360845308, "pass@100": 0.05906180468454194}

evaluation/results/tr11/templates.txt

@@ -0,0 +1,65 @@
+piaf,None,None,"Given_above_context"
+piaf,None,None,"given_passage_answer"
+piaf,None,None,"context_follow_q"
+piaf,None,None,"after_reading"
+piaf,None,None,"extract_the_answer"
+GEM/wiki_lingua,ar,ar,"article_summary_ar"
+GEM/wiki_lingua,ar,ar,"write_abstract_ar"
+GEM/wiki_lingua,ar,ar,"summarize_above_ar"
+GEM/wiki_lingua,ar,ar,"rephrase_ar"
+GEM/wiki_lingua,ar,ar,"tldr_ar"
+GEM/wiki_lingua,en,en,"article_summary_en"
+GEM/wiki_lingua,en,en,"write_abstract_en"
+GEM/wiki_lingua,en,en,"summarize_above_en"
+GEM/wiki_lingua,en,en,"rephrase_en"
+GEM/wiki_lingua,en,en,"tldr_en"
+GEM/wiki_lingua,es,es,"article_summary_es"
+GEM/wiki_lingua,es,es,"write_abstract_es"
+GEM/wiki_lingua,es,es,"summarize_above_es"
+GEM/wiki_lingua,es,es,"rephrase_es"
+GEM/wiki_lingua,es,es,"tldr_es"
+GEM/wiki_lingua,fr,fr,"article_summary_fr"
+GEM/wiki_lingua,fr,fr,"write_abstract_fr"
+GEM/wiki_lingua,fr,fr,"summarize_above_fr"
+GEM/wiki_lingua,fr,fr,"rephrase_fr"
+GEM/wiki_lingua,fr,fr,"tldr_fr"
+GEM/wiki_lingua,hi,hi,"article_summary_hi"
+GEM/wiki_lingua,hi,hi,"write_abstract_hi"
+GEM/wiki_lingua,hi,hi,"summarize_above_hi"
+GEM/wiki_lingua,hi,hi,"rephrase_hi"
+GEM/wiki_lingua,hi,hi,"tldr_hi"
+GEM/wiki_lingua,id,id,"article_summary_id"
+GEM/wiki_lingua,id,id,"write_abstract_id"
+GEM/wiki_lingua,id,id,"summarize_above_id"
+GEM/wiki_lingua,id,id,"rephrase_id"
+GEM/wiki_lingua,id,id,"tldr_id"
+GEM/wiki_lingua,pt,pt,"article_summary_pt"
+GEM/wiki_lingua,pt,pt,"write_abstract_pt"
+GEM/wiki_lingua,pt,pt,"summarize_above_pt"
+GEM/wiki_lingua,pt,pt,"rephrase_pt"
+GEM/wiki_lingua,pt,pt,"tldr_pt"
+GEM/wiki_lingua,vi,vi,"article_summary_vi"
+GEM/wiki_lingua,vi,vi,"write_abstract_vi"
+GEM/wiki_lingua,vi,vi,"summarize_above_vi"
+GEM/wiki_lingua,vi,vi,"rephrase_vi"
+GEM/wiki_lingua,vi,vi,"tldr_vi"
+GEM/wiki_lingua,zh,zh,"article_summary_zh"
+GEM/wiki_lingua,zh,zh,"write_abstract_zh"
+GEM/wiki_lingua,zh,zh,"summarize_above_zh"
+GEM/wiki_lingua,zh,zh,"rephrase_zh"
+GEM/wiki_lingua,zh,zh,"tldr_zh"
+GEM/web_nlg,en,en,"use-category"
+GEM/web_nlg,en,en,"PALM_prompt"
+GEM/web_nlg,en,en,"very-explicit-description"
+GEM/web_nlg,en,en,"explicit-graph-description2"
+GEM/web_nlg,en,en,"non-explicit-description"
+GEM/web_nlg,ru,ru,"use-category"
+GEM/web_nlg,ru,ru,"PAM-russian"
+GEM/web_nlg,ru,ru,"PALM_prompt"
+GEM/web_nlg,ru,ru,"explicit-graph-description-2-Russian"
+GEM/web_nlg,ru,ru,"explicit-graph-description"
+wmt14,fr-en,fr-en,"version-en-fr-target"
+wmt14,fr-en,fr-en,"a_good_translation-fr-en-target"
+wmt14,fr-en,fr-en,"a_good_translation-en-fr-source+target"
+wmt14,fr-en,fr-en,"xglm-en-fr-source-target"
+wmt14,fr-en,fr-en,"gpt3-en-fr"

evaluation/results/tr13/lmeval/download_bslmeval.slurm

@@ -0,0 +1,37 @@
+#!/bin/bash
+#SBATCH --job-name=download-bslmeval
+#SBATCH --partition=prepost
+#SBATCH --nodes=1
+#SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
+#SBATCH --cpus-per-task=10           # 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 --account=six@cpu
+
+set -x -e
+
+echo "START TIME: $(date)"
+
+source $six_ALL_CCFRWORK/start-py38-pt111
+conda activate muennighofflmeval
+
+#export HF_DATASETS_OFFLINE=1
+#export TRANSFORMERS_OFFLINE=1
+
+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 TOKENIZERS_PARALLELISM=false
+
+cd /gpfsscratch/rech/six/commun/experiments/muennighoff/bloomckpt/lm-evaluation-harness
+
+#  GEM/web_nlg_en,GEM/web_nlg_en_challenge_test_numbers,GEM/web_nlg_en_challenge_test_scramble,GEM/web_nlg_en_challenge_validation_sample,GEM/web_nlg_ru,GEM/web_nlg_ru_challenge_test_scramble,GEM/web_nlg_ru_challenge_validation_sample,GEM/wiki_auto_asset_turk_challenge_test_asset_backtranslation,GEM/wiki_auto_asset_turk_challenge_test_asset_bfp02,GEM/wiki_auto_asset_turk_challenge_test_asset_bfp05,GEM/wiki_auto_asset_turk_challenge_test_asset_nopunc,GEM/wiki_auto_asset_turk_challenge_test_turk_backtranslation,GEM/wiki_auto_asset_turk_challenge_test_turk_bfp02,GEM/wiki_auto_asset_turk_challenge_test_turk_bfp05,GEM/wiki_auto_asset_turk_challenge_test_turk_nopunc,GEM/wiki_auto_asset_turk_test_asset,GEM/wiki_auto_asset_turk_test_turk,GEM/wiki_lingua_ar,GEM/wiki_lingua_cs,GEM/wiki_lingua_de,GEM/wiki_lingua_en,GEM/wiki_lingua_es,GEM/wiki_lingua_fr,GEM/wiki_lingua_hi,GEM/wiki_lingua_id,GEM/wiki_lingua_it,GEM/wiki_lingua_ja,GEM/wiki_lingua_ko,GEM/wiki_lingua_nl,GEM/wiki_lingua_pt,GEM/wiki_lingua_ru,GEM/wiki_lingua_th,GEM/wiki_lingua_tr,GEM/wiki_lingua_vi,GEM/wiki_lingua_zh,gem_xsum,gem_xsum_challenge_sample,gem_xsum_challenge_test_backtranslation,gem_xsum_challenge_test_bfp_02,gem_xsum_challenge_test_bfp_05,gem_xsum_challenge_test_covid,gem_xsum_challenge_test_nopunc \
+python3 main.py --model hf-causal \
+    --model_args pretrained=hf-internal-testing/tiny-random-gpt2,use_accelerate=True,tokenizer=hf-internal-testing/tiny-random-gpt2,dtype=float16 \
+    --tasks wmt14_fr_en,wmt19_ru_en,wmt19_zh_en \
+    --device cuda \
+    --limit 1 \
+    --no_cache \
+    --num_fewshot 0

evaluation/results/tr13/tzeroeval/convert_validation_2b5.slurm

@@ -0,0 +1,352 @@
+#!/bin/bash
+#SBATCH --job-name=ckpts
+#SBATCH --ntasks=1                   # number of MP tasks
+#SBATCH --nodes=1
+#SBATCH --cpus-per-task=40           # 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 --account=ajs@cpu
+#SBATCH --partition=cpu_p1
+
+set -x -e
+
+source $six_ALL_CCFRWORK/start-tr13f-6B3-ml-t0
+export HF_DATASETS_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+conda activate muennighoffmodelconv
+
+CKPT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr13c-2B5-ml-t0/checkpoints/xp3capmixnewcodelonglossseq
+#CKPT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr13f-6B3-ml-t0/checkpoints/p31lossseq
+
+CKPTS=(
+global_step250
+global_step500
+global_step750
+global_step1000
+global_step1250
+global_step1500
+global_step1750
+global_step2000
+global_step2250
+global_step2500
+global_step2750
+global_step3000
+)
+EXAMPLE_CKPT=$six_ALL_CCFRSCRATCH/commun/experiments/muennighoff/bloomckpt/2b5/bloom-2b5
+DUMP_PATH=$six_ALL_CCFRSCRATCH/commun/experiments/muennighoff/bloomckpt/2b5t0
+OUT_PREFIX=xp3capmixlossseq_
+#OUT_PREFIX=p31lossseq
+
+TP=1
+
+### CONVERT ###
+
+
+for i in {0..11}; do
+CKPT=${CKPTS[$i]}
+echo "$i"
+echo "Running $CKPT"
+
+OUTPUTCKPT=$DUMP_PATH/"$OUT_PREFIX$CKPT"
+python $six_ALL_CCFRSCRATCH/commun/experiments/muennighoff/bloomckpt/transformers_clone/src/transformers/models/bloom/convert_bloom_original_checkpoint_to_pytorch.py --pytorch_dump_folder_path $OUTPUTCKPT --bloom_checkpoint_path $CKPT_PATH/$CKPT --pretraining_tp $TP --bloom_config_file $EXAMPLE_CKPT/config.json
+
+# Copy tokenizer.json etc
+cp -r $EXAMPLE_CKPT/*.json $OUTPUTCKPT/
+
+eval_script="./eval_$i.slurm"
+cat <<EOT > $eval_script
+#!/bin/bash
+#SBATCH --job-name=evaluate_t0
+#SBATCH --nodes=1
+#SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
+#SBATCH --cpus-per-task=8           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --gres=gpu:1                 # number of gpus
+#SBATCH --constraint=a100
+#SBATCH --time 5:00:00             # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --account=six@a100
+#SBATCH --array=0-168
+
+set -x -e
+
+source $six_ALL_CCFRWORK/start-py38-pt111
+conda activate thomas_t_zero_evaluation
+
+CHECKPOINT_PATH=$OUTPUTCKPT
+
+WORKDIR=/gpfswork/rech/six/commun/code/tr13f-6B3-ml-t0
+pushd "\$WORKDIR"
+OUTPUT_DIR="\$CHECKPOINT_PATH/evaluation"
+mkdir -p "\$OUTPUT_DIR"
+
+# Validation
+DATASETS_AND_CONFIGS_VAL=(
+head_qa,en,en,"multiple_choice_q_and_a_index_with_context_en",validation
+head_qa,en,en,"multiple_choice_q_and_a_en",validation
+head_qa,en,en,"multiple_choice_q_and_a_index_en",validation
+head_qa,en,en,"multiple_choice_a_and_q_with_context_en",validation
+head_qa,en,en,"multiple_choice_a_and_q_en",validation
+head_qa,es,en,"multiple_choice_q_and_a_index_with_context_en",validation
+head_qa,es,en,"multiple_choice_q_and_a_en",validation
+head_qa,es,en,"multiple_choice_q_and_a_index_en",validation
+head_qa,es,en,"multiple_choice_a_and_q_with_context_en",validation
+head_qa,es,en,"multiple_choice_a_and_q_en",validation
+climate_fever,None,None,"first_evidence_and_claim_itemization",test
+climate_fever,None,None,"claim_and_all_supporting_evidences",test
+climate_fever,None,None,"fifth_evidence_and_claim_itemization",test
+climate_fever,None,None,"third_evidence_claim_pair",test
+climate_fever,None,None,"second_evidence_and_claim_itemization",test
+codah,codah,None,"interrogative_instruction_after_sentence_and_choices",train
+codah,codah,None,"affirmative_instruction_before_sentence_and_choices",train
+codah,codah,None,"affirmative_instruction_after_sentence_and_choices",train
+aqua_rat,raw,None,"select_the_best_option",validation
+aqua_rat,raw,None,"answer_quiz",validation
+aqua_rat,raw,None,"Answer questions from options",validation
+commonsense_qa,None,None,"answer_given_question_without_options",validation
+commonsense_qa,None,None,"question_answering",validation
+commonsense_qa,None,None,"most_suitable_answer",validation
+amazon_reviews_multi,en,en,"prompt_title_to_star",validation
+amazon_reviews_multi,en,en,"prompt_review_to_star",validation
+amazon_reviews_multi,en,en,"prompt_body_title_to_star",validation
+amazon_reviews_multi,zh,en,"prompt_title_to_star",validation
+amazon_reviews_multi,zh,en,"prompt_review_to_star",validation
+amazon_reviews_multi,zh,en,"prompt_body_title_to_star",validation
+amazon_reviews_multi,fr,en,"prompt_title_to_star",validation
+amazon_reviews_multi,fr,en,"prompt_review_to_star",validation
+amazon_reviews_multi,fr,en,"prompt_body_title_to_star",validation
+amazon_reviews_multi,es,en,"prompt_title_to_star",validation
+amazon_reviews_multi,es,en,"prompt_review_to_star",validation
+amazon_reviews_multi,es,en,"prompt_body_title_to_star",validation
+art,None,None,"choose_hypothesis_options",validation
+art,None,None,"choose_hypothesis_believable",validation
+art,None,None,"choose_hypothesis",validation
+art,None,None,"choose_hypothesis_desc",validation
+art,None,None,"choose_hypothesis_likely",validation
+banking77,None,None,"help_page_topic",test
+banking77,None,None,"direct_to_which_department",test
+banking77,None,None,"rephrase_as_banking_term",test
+blbooksgenre,title_genre_classifiction,None,"multi-choice",train
+blbooksgenre,title_genre_classifiction,None,"premise_context_first",train
+blbooksgenre,title_genre_classifiction,None,"classify",train
+blimp,adjunct_island,None,"grammatical_between_1_2",train
+blimp,adjunct_island,None,"grammatical_between_A_B",train
+blimp,adjunct_island,None,"grammatical_which_one_1_2",train
+blimp,adjunct_island,None,"single_sentence_bad_yes_no",train
+blimp,adjunct_island,None,"single_sentence_good_yes_no",train
+conv_ai_3,None,None,"clarification_needed",validation
+conv_ai_3,None,None,"score_give_number",validation
+conv_ai_3,None,None,"ambiguous",validation
+conv_ai_3,None,None,"directly_answer",validation
+conv_ai_3,None,None,"score_how_much",validation
+craigslist_bargains,None,None,"good deal for seller no list price implicit",validation
+craigslist_bargains,None,None,"good deal for seller no list price",validation
+craigslist_bargains,None,None,"good deal for seller",validation
+craigslist_bargains,None,None,"best deal",validation
+ecthr_cases,alleged-violation-prediction,None,"implicit_advice_number",validation
+ecthr_cases,alleged-violation-prediction,None,"ecthr_alleged_articles_declaration_at_end",validation
+ecthr_cases,alleged-violation-prediction,None,"ecthr_alleged_articles_question_at_start",validation
+ecthr_cases,alleged-violation-prediction,None,"implicit_judgment_paragraph",validation
+ecthr_cases,alleged-violation-prediction,None,"confirm number of violated articles",validation
+emo,None,None,"persons_describe",validation
+emo,None,None,"final_message",validation
+emo,None,None,"what_emotion_do_you_think",validation
+emo,None,None,"emotional_state",validation
+emo,None,None,"dialogue_between",validation
+emotion,None,None,"choose_the_best_emotion_label",test
+emotion,None,None,"reply_with_emoation_label",test
+emotion,None,None,"answer_with_class_label",test
+emotion,None,None,"answer_question_with_emotion_label",test
+financial_phrasebank,sentences_allagree,None,"share_price_option",train
+financial_phrasebank,sentences_allagree,None,"sentiment",train
+financial_phrasebank,sentences_allagree,None,"word_comes_to_mind",train
+financial_phrasebank,sentences_allagree,None,"complementary_industries",train
+financial_phrasebank,sentences_allagree,None,"bullish_neutral_bearish",train
+glue,cola,None,"Make sense yes no",validation
+glue,cola,None,"is_this_correct",validation
+glue,cola,None,"editing",validation
+glue,cola,None,"Following sentence acceptable",validation
+glue,cola,None,"Previous sentence acceptable",validation
+glue,sst2,None,"positive negative after",validation
+glue,sst2,None,"review",validation
+glue,sst2,None,"said",validation
+glue,sst2,None,"following positive negative",validation
+glue,sst2,None,"happy or mad",validation
+health_fact,None,None,"claim_veracity_classification_after_reading_I_believe",validation
+health_fact,None,None,"claim_explanation_classification",validation
+health_fact,None,None,"claim_veracity_classification_tell_me",validation
+hlgd,None,None,"is_same_event_with_time_interrogative_related",validation
+hlgd,None,None,"is_same_event_interrogative_talk",validation
+hlgd,None,None,"is_same_event_with_time_interrogative_talk",validation
+hlgd,None,None,"is_same_event_refer",validation
+hlgd,None,None,"is_same_event_editor_asks",validation
+hyperpartisan_news_detection,byarticle,None,"consider_does_it_follow_a_hyperpartisan_argumentation",train
+hyperpartisan_news_detection,byarticle,None,"follows_hyperpartisan_argumentation",train
+hyperpartisan_news_detection,byarticle,None,"consume_with_caution",train
+hyperpartisan_news_detection,byarticle,None,"extreme_left_wing_or_right_wing",train
+hyperpartisan_news_detection,byarticle,None,"consider_it_exhibits_extreme_one_sidedness",train
+liar,None,None,"Given statement guess category",validation
+lince,sa_spaeng,None,"original poster expressed sentiment",validation
+lince,sa_spaeng,None,"sentiment trying to express",validation
+lince,sa_spaeng,None,"express sentiment",validation
+lince,sa_spaeng,None,"negation template",validation
+lince,sa_spaeng,None,"the author seem",validation
+math_qa,None,None,"choose_correct_og",test
+math_qa,None,None,"pick_the_correct",test
+math_qa,None,None,"first_choice_then_problem",test
+math_qa,None,None,"problem_set_type",test
+math_qa,None,None,"gre_problem",test
+movie_rationales,None,None,"Standard binary sentiment analysis",validation
+movie_rationales,None,None,"Evidences sentiment classification",validation
+movie_rationales,None,None,"Evidences + review",validation
+movie_rationales,None,None,"Generate evidences and sentiment",validation
+mwsc,None,None,"in-the-sentence-question-first",validation
+mwsc,None,None,"what-think",validation
+mwsc,None,None,"in-the-sentence",validation
+mwsc,None,None,"options-or",validation
+mwsc,None,None,"is-correct",validation
+poem_sentiment,None,None,"positive_or_negative_sentiment_variation_2",validation
+poem_sentiment,None,None,"question_answer_format",validation
+poem_sentiment,None,None,"guess_sentiment_without_options_variation_1",validation
+poem_sentiment,None,None,"positive_or_negative_sentiment_variation_1",validation
+poem_sentiment,None,None,"most_appropriate_sentiment",validation
+onestop_english,None,None,"esl_context",train
+onestop_english,None,None,"ara_context",train
+onestop_english,None,None,"determine_reading_level_from_the_first_three_sentences",train
+onestop_english,None,None,"esl_variation",train
+onestop_english,None,None,"assess",train
+pubmed_qa,pqa_labeled,None,"Long Answer to Final Decision",train
+pubmed_qa,pqa_labeled,None,"Question Answering (Short)",train
+riddle_sense,None,None,"most_suitable_answer",validation
+riddle_sense,None,None,"answer_given_question_without_options",validation
+riddle_sense,None,None,"question_to_answer_index",validation
+riddle_sense,None,None,"question_answering",validation
+scicite,None,None,"Classify intent w/section (select choice)",validation
+scicite,None,None,"Classify intent (choices first)",validation
+scicite,None,None,"Classify intent (select choice)",validation
+scicite,None,None,"Classify intent",validation
+scicite,None,None,"can_describe",validation
+selqa,answer_selection_analysis,None,"is-he-talking-about",validation
+selqa,answer_selection_analysis,None,"would-make-sense-qu-rand",validation
+selqa,answer_selection_analysis,None,"make-sense-rand",validation
+selqa,answer_selection_analysis,None,"which-answer-1st-vs-random",validation
+snips_built_in_intents,None,None,"voice_intent",train
+snips_built_in_intents,None,None,"categorize_query",train
+snips_built_in_intents,None,None,"intent_query",train
+snips_built_in_intents,None,None,"categorize_query_brief",train
+snips_built_in_intents,None,None,"query_intent",train
+)
+
+DATASET_AND_CONFIG="\${DATASETS_AND_CONFIGS_VAL[\$SLURM_ARRAY_TASK_ID]}"
+echo "\$ARGUMENT"
+
+# Run T0 evaluation
+# For PrefixLM add --prefixlm
+IFS=',' read dataset_name dataset_config_name template_config_name template_name split <<< "\${DATASET_AND_CONFIG}"
+python t-zero/evaluation/run_eval.py \
+        --dataset_name "\$dataset_name" \
+        --dataset_config_name "\$dataset_config_name" \
+        --template_config_name "\$template_config_name" \
+        --template_name "\$template_name" \
+        --split "\$split" \
+        --model_name_or_path "\$CHECKPOINT_PATH" \
+        --output_dir "\$OUTPUT_DIR" \
+        --per_device_eval_batch_size 4 \
+        --max_length 2048 \
+        --dtype float16
+EOT
+
+sbatch $eval_script
+
+
+lm_eval_script="./lm_eval_$i.slurm"
+cat <<EOT > $lm_eval_script
+#!/bin/bash
+#SBATCH --job-name=lmeval
+#SBATCH --nodes=1
+#SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
+#SBATCH --cpus-per-task=8           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --gres=gpu:1                 # number of gpus
+#SBATCH --constraint=a100
+#SBATCH --time 20:00:00             # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x-%j.out           # output file name
+#SBATCH --account=six@a100
+#SBATCH --array=0-22
+
+set -x -e
+
+source $six_ALL_CCFRWORK/start-tr13f-6B3-ml-t0
+conda activate muennighofflmevalgen
+
+echo "START TIME: $(date)"
+
+# 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
+export TOKENIZERS_PARALLELISM=false
+
+# Converted transformer checkpoint
+MODEL_CKPT=$OUTPUTCKPT
+
+cd /gpfsscratch/rech/six/commun/experiments/muennighoff/lm-evaluation-harness
+
+
+DATASETS_AND_CONFIGS=(
+wmt14_fr_en,fr-en,"version-en-fr-target"
+wmt14_fr_en,fr-en,"a_good_translation-en-fr-target"
+wmt14_fr_en,fr-en,"a_good_translation-en-fr-source+target"
+wmt14_fr_en,fr-en,"xglm-en-fr-target"
+wmt14_fr_en,fr-en,"gpt3-en-fr"
+wmt14_fr_en,fr-en,"version-fr-en-target"
+wmt14_fr_en,fr-en,"a_good_translation-fr-en-target"
+wmt14_fr_en,fr-en,"a_good_translation-fr-en-source+target"
+wmt14_fr_en,fr-en,"xglm-fr-en-target"
+wmt14_fr_en,fr-en,"gpt3-fr-en"
+wmt14_hi_en,hi-en,"version-en-hi-target"
+wmt14_hi_en,hi-en,"a_good_translation-en-hi-target"
+wmt14_hi_en,hi-en,"a_good_translation-en-hi-source+target"
+wmt14_hi_en,hi-en,"xglm-en-hi-target"
+wmt14_hi_en,hi-en,"gpt-3-en-hi-target"
+wmt14_hi_en,hi-en,"version-hi-en-target"
+wmt14_hi_en,hi-en,"a_good_translation-hi-en-target"
+wmt14_hi_en,hi-en,"a_good_translation-hi-en-source+target"
+wmt14_hi_en,hi-en,"xglm-hi-en-target"
+wmt14_hi_en,hi-en,"gpt-3-hi-en-target"
+mlsum_es,"es","layman_summ_es"
+mlsum_es,"es","palm_prompt"
+mlsum_es,"es","summarise_this_in_es_few_sentences"
+)
+
+DATASET_AND_CONFIG="\${DATASETS_AND_CONFIGS[\$SLURM_ARRAY_TASK_ID]}"
+echo "\$ARGUMENT"
+
+IFS=',' read dataset_name lang template_name <<< "\${DATASET_AND_CONFIG}"
+
+# Use this fork of lm-eval: https://github.com/bigscience-workshop/lm-evaluation-harness/pull/109
+python main.py \
+    --model_api_name 'hf-causal' \
+    --model_args "pretrained=\$MODEL_CKPT,use_accelerate=True,tokenizer=\$MODEL_CKPT,dtype=float16" \
+    --device cuda \
+    --batch_size 16 \
+    --no_tracking \
+    --task_name "\$dataset_name" \
+    --template_names "\$template_name" \
+    --bootstrap_iters 10 \
+    --limit 3000
+
+mkdir -p "$OUTPUTCKPT/evaluation/\$dataset_name"
+mv "outputs/*$CKPT*\$dataset_name*" "$OUTPUTCKPT/evaluation/\$dataset_name/"
+
+echo "END TIME: $(date)"
+EOT
+
+sbatch $lm_eval_script
+
+
+done

train/tr1-13B-base/README.md

@@ -0,0 +1,850 @@
+# Train 1 - 13B - unmodified Megatron gpt2 - baseline
+
+
+## Task
+
+Auto-regressive objective using regular Megatron-LM GPT2 language model
+
+## Environment
+
+To launch the environment use [start-tr1-13B](./start-tr1-13B)
+
+```
+source $six_ALL_CCFRWORK/code/tr1-13B/bigscience/train/tr1-13B-base/start-tr1-13B
+```
+
+We are using the following branches specific to this training:
+
+- `$six_ALL_CCFRWORK/code/tr1-13B/Megatron-DeepSpeed-tr1-13B` a frozen `tr1-13B` branch - can cherry pick from `main` if need be.
+- `$six_ALL_CCFRWORK/code/tr1-13B/DeepSpeed-big-science` - a mostly frozen `big-science` branch - under Deepspeed's team control - so it may also require a specific SHA if something gets broken upstream.
+
+
+How the environment was built:
+```
+export CONDA_ENVS_PATH=$six_ALL_CCFRWORK/conda
+
+conda create -y -n tr1-13B python=3.8
+conda activate tr1-13B
+conda install pytorch==1.8.1 torchvision cudatoolkit=10.2 -c pytorch -y
+pip install deepspeed
+pip install tensorboard
+
+mkdir $six_ALL_CCFRWORK/code/tr1-13B
+
+cd $six_ALL_CCFRWORK/code/tr1-13B
+git clone https://github.com/bigscience-workshop/bigscience
+
+cd $six_ALL_CCFRWORK/code/tr1-13B
+git clone https://github.com/huggingface/transformers
+cd transformers
+pip install -e .
+
+cd $six_ALL_CCFRWORK/code/tr1-13B
+git clone https://github.com/bigscience-workshop/Megatron-DeepSpeed Megatron-DeepSpeed-tr1-13B
+cd Megatron-DeepSpeed-tr1-13B
+git checkout tr1-13B
+pip install -r requirements.txt
+pip install -e .
+mkdir data
+cd data
+wget https://s3.amazonaws.com/models.huggingface.co/bert/gpt2-vocab.json
+wget https://s3.amazonaws.com/models.huggingface.co/bert/gpt2-merges.txt
+```
+
+`apex` and `deepspeed` build require an instance w/ beefy cpu and internet (unless cloned beforehand), so continue on the `prepost` partition:
+
+```
+ssh jean-zay-pp
+conda activate tr1-13B
+export CONDA_ENVS_PATH=$six_ALL_CCFRWORK/conda
+
+cd $six_ALL_CCFRWORK/code/tr1-13B
+git clone https://github.com/microsoft/DeepSpeed DeepSpeed-big-science
+cd DeepSpeed-big-science
+git checkout big-science
+rm -rf build
+TORCH_CUDA_ARCH_LIST="7.0" DS_BUILD_CPU_ADAM=1 DS_BUILD_AIO=1 DS_BUILD_UTILS=1 pip install -e . --global-option="build_ext" --global-option="-j8" --no-cache -v --disable-pip-version-check 2>&1 | tee build.log
+
+cd $six_ALL_CCFRWORK/code/tr1-13B
+git clone https://github.com/NVIDIA/apex
+cd apex
+pip install --global-option="--cpp_ext" --global-option="--cuda_ext" --no-cache -v --disable-pip-version-check .  2>&1 | tee build.log
+
+#cp $six_ALL_CCFRWORK/code/tr1-13B/bigscience/train/tr1-13B-base/start-tr1-13B ...
+
+```
+
+
+## Architecture
+
+Config:
+
+```
+NLAYERS=40
+NHIDDEN=5120
+NHEADS=32
+FFN_HIDDEN_SIZE=20480
+
+#    --ffn_hidden_size $FFN_HIDDEN_SIZE \
+GPT_ARGS=" \
+    --num-layers $NLAYERS \
+    --hidden-size $NHIDDEN \
+    --ffn-hidden-size $FFN_HIDDEN_SIZE \
+    --num-attention-heads $NHEADS \
+    [...]
+    "
+```
+
+Sanity check:
+```
+$ VOCAB_SIZE=50257 NLAYERS=40 NHIDDEN=5120 NHEADS=32 SEQ_LEN=2048; python -c "h=$NHIDDEN; l=$NLAYERS; s=$SEQ_LEN; v=$VOCAB_SIZE; print(f'Model size: {(l * (12*h**2 + 13*h) + (v * h) + (s * h) ) / 10**9 :.0f}B')"
+Model size: 13B
+```
+
+
+
+## Sequence Length
+
+Default Megatron-LM language model with 2048 tokens sequence length
+
+```
+SEQ_LEN=2048
+
+    --seq-length $SEQ_LEN \
+    --max-position-embeddings $SEQ_LEN \
+
+```
+
+
+## Global batch size
+
+GBS = Global Batch Size
+
+Use a schedule:
+
+- start from 32k tokens (gbs=16)
+- increase linearly to 2048k (gbs=1024) over 5M samples (for a total of ~10B tokens / 5k steps)
+- then continue at 2048k  (gbs=1024) for 145M samples (290B tokens / 145K steps)
+
+Total: 300B tokens (150K steps)
+
+Note: the training script wasn't updated when we flipped seqlen/gbs from 1024/2048 to 2048/1024, so we are currently planning to train for 300K steps (samples) and 600B tokens. But since longer doesn't impact anything, we will just stop at half the time. I updated the document to use the right 150K number so we don't repeat this mistake in the next training.
+
+syntax:
+```
+--rampup-batch-size <start batch size>  <batch size increment> <ramp-up samples>
+```
+
+At seqlen 2048 (1k tokens is bs=1), we get:
+
+```
+    --rampup-batch-size 16 16 5_000_000 \
+    --global-batch-size 1024 \
+```
+
+This means it will start with global batch size 16 and over 63 (`(1024-16)/16`) intervals will increase the
+batch size by 16 linearly to 1024.
+
+79365 (`5_000_000/63`) is the number of samples before the next GBS increment. That is we run at GBS=16 for 79365 samples, or 4960 steps (`79365/16`). Then we run at GBS=32 for 79365 samples, or 2480 steps. Then 1653 steps at GBS=48, 1240 at GBS=64, etc....
+
+Notes:
+* `--rampup-batch-size` requires the use of `--train-samples` and can't be used with `--train-iters`.
+* global batch size has to be divisible by micro-batch-size * DP_SIZE
+
+Important:  the software will fail if GBS is not divisible by `MBS * DP_SIZE`.
+Though Jared's recommendation is to use MBS=1 and then it's much easier to match GBS/DP_SIZE even at GBS=16.
+
+`DP_SIZE=$NNODES*$GPUS_PER_NODE/($PP_SIZE*$TP_SIZE)`
+
+Since the increments are in GBS=16, we can do only DP_SIZE=16, which means that at most we can use 32 nodes (`32*4/(4*2)=16`).
+
+Once GBS reaches 1024, we can use up to 8192 GPUs (1024*2*4), so we will be able to switch to 64 nodes or may be even 128 nodes (4 gpus each). We can't use any number of nodes between 64 and 128 though, because the number has to be 2**X. So 96 nodes won't work, because it has a multiplier of 3 there.
+
+
+
+
+## Checkpoints
+
+We need the checkpoints:
+
+1. in order to be able to resume the training when the training is prematurely stopped for whatever reason.
+2. In addition a special saving schedule has been requested by the interpretabity group.
+
+Because there are 3 different schedules, and Megatron-LM has only fixed checkpoint saving schedule, we will need 3 different run scripts, to be launched in a sequence, each starting once the previous has finished.
+
+1. steps 1-100 - 10 checkpoints, interval 10 steps
+2. steps 101-1000 - 50 checkpoints, interval 18 steps
+3. steps 1001-150K - 100+ checkpoints, interval 1500 steps
+4. if still needed, can continue with schedule 3
+
+note: the interoperability study doesn't care for checkpoints in the range of 1k-20k, so we only save those to be able to restart the training.
+
+It'd have been
+```
+ROUND=1
+if   [[ ${ROUND} == 1 ]]; then TRAIN_ITER=100    SAVE_INTERVAL=10
+elif [[ ${ROUND} == 2 ]]; then TRAIN_ITER=1000   SAVE_INTERVAL=18
+elif [[ ${ROUND} == 3 ]]; then TRAIN_ITER=150000 SAVE_INTERVAL=1500
+else echo "invalid ROUND: $ROUND"
+fi
+    --train-iter $TRAIN_ITER  \
+    --save-interval $SAVE_INTERVAL  \
+```
+
+Unfortunately, `--rampup-batch-size` can't work with `--train-iter` and we have to use `--train-samples` instead. It has to be fixed through all of trainings and can't be changed, otherwise resume from checkpoint will break.
+
+So the only thing left is to use `--exit-interval` which is in steps.
+
+Which gives us the three rounds:
+
+```
+ROUND=1
+if   [[ ${ROUND} == 1 ]]; then EXIT_INTERVAL=100 SAVE_INTERVAL=10
+elif [[ ${ROUND} == 2 ]]; then EXIT_INTERVAL=900 SAVE_INTERVAL=18
+elif [[ ${ROUND} == 3 ]]; then                   SAVE_INTERVAL=1500
+else echo "invalid ROUND: $ROUND"
+fi
+
+    --train-samples 150_000_000 \
+    --exit-interval $EXIT_INTERVAL \
+    --save-interval $SAVE_INTERVAL  \
+```
+
+`--exit-interval` counts steps only for the current run, regardless of previous steps. So to stop at effective step 1000, the second round we tell it to exit at 900 (the first round did the first 100).
+
+And unfortunately, this proved to be not supported by Megatron-LM either at the moment. There are a few possible ways to approach this:
+
+1. One approach is to simply use 3 independent trainings, while using the same `--seed ` and just have `--exit_interval` as above. Though after each training moving the checkpoints away.
+
+2.
+XXX: Also megatron code could be extended to implement `--exit-samples` - so sample-based exit strategy
+
+3. Yet another approach is to do it manually. Kill the training after 100, and then restart and kill after 900 iterations, while changing the save interval, and manually fixing up the `checkpoints/latest` to point to the correct checkpoint - since the manual killing might have a few extra checkpoints. So the recipe to follow:
+
+```
+ROUND=1
+if   [[ ${ROUND} == 1 ]]; then SAVE_INTERVAL=10
+elif [[ ${ROUND} == 2 ]]; then SAVE_INTERVAL=18
+elif [[ ${ROUND} == 3 ]]; then SAVE_INTERVAL=1500
+else echo "invalid ROUND: $ROUND"
+fi
+
+    --train-samples 150_000_000 \
+    --save-interval $SAVE_INTERVAL  \
+```
+
+(could also do it with 3 parallel jobs by using the same seed!)
+
+```
+--seed 42
+```
+
+Therefore do this manually:
+
+0.
+* delete the old checkpoints `$six_ALL_CCFRSCRATCH/checkpoints/tr1-13B/checkpoints`
+
+1.
+
+* set to `ROUND=1`
+* `sbatch tr1-13B-round1.slurm`
+* run for 100+ steps
+* scancel the job
+* clean up `$six_ALL_CCFRSCRATCH/checkpoints/tr1-13B/checkpoints` to remove any checkpoints beyond 100
+* make sure `$six_ALL_CCFRSCRATCH/checkpoints/tr1-13B/checkpoints/latest` contains 100
+
+
+2.
+
+* set to `ROUND=2`
+* `sbatch tr1-13B-round1.slurm`
+* run for the additional 900+ steps (it's incremental, so the script already knows it started at 100)
+* scancel the job
+* clean up `$six_ALL_CCFRSCRATCH/checkpoints/tr1-13B/checkpoints` to remove any checkpoints beyond 1000
+* make sure `$six_ALL_CCFRSCRATCH/checkpoints/tr1-13B/checkpoints/latest` contains 1000
+
+
+3.
+
+* set to `ROUND=3`
+* `sbatch tr1-13B-round1.slurm`
+* run normally
+
+
+
+Because it'd be potentially too demanding to export TBs of data and the intended users might not be even able to download all that data, most likely we will need to run the interpretabity post-analysis experiments on JZ and send the reports to those who need the reports.
+
+Megatron-LM resumes from the most recent checkpoint by default. Does it need the exact path or does it auto-discover the latest checkpoint by default.
+
+```
+--load path_to_check_point \
+```
+
+
+Remi suggests 100TB on SCRATCH shouldn't be a problem.
+
+
+
+
+
+## Optimizer
+
+- AdamW,  β1=0.9, β2=0.999 eps=1e−8
+- learning rate:
+   * peak=1e-4
+   * warmup over 2000 steps
+   * cosine decay for learning rate down to 10% of its value, over 260B tokens (after 260 billion tokens, training continues at 10% of the original learning rate)
+- clipping by global norm of 1 (as in GPT-3)
+- weight decay of 0.1
+
+We need lr-decay in samples, so tokens2samples = 260B / 2048 = 126_953_125
+
+We need lr-warmup in samples, so doing the math again as in checkpoints
+
+2000=160*12+80
+
+so we will get to 2000 in 216_320 samples `16*160*12*(12+1)/2+16*13*80`
+
+
+
+```
+    --optimizer adam \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.999 \
+    --adam-eps 1e-8 \
+    --lr 1e-4 \
+    --min-lr 1e-5 \
+    --lr-decay-style cosine \
+    --lr-decay-samples 126_953_125 \
+    --lr-warmup-samples 216_320 \
+    --clip-grad 1.0 \
+    --weight-decay 1e-1 \
+```
+
+
+## Logging
+
+
+For now enable all tensorboard features, later we might decide to not log it all.
+
+We are logging:
+
+- lr (enabled by default)
+- bs (enabled)
+- loss (always)
+- loss-scale (log_loss) (enabled by default)
+- grad-norm (always)
+- num-zeros (always)
+- param-norm (always)
+- timers (enabled)
+- validation loss (always)
+- validation ppl (perplexity) (enabled)
+
+almost all of these are also logged as a comparison to consumed_train_samples
+
+XXX: nice to have:
+- throughput - Tflops/gpu or tokens
+
+
+**Tensorboard config**:
+
+```
+TENSORBOARD_PATH=$DATA_OUTPUT_PATH/tensorboard
+
+    --tensorboard-dir $TENSORBOARD_PATH \
+    --tensorboard-queue-size 5 \
+    --log-timers-to-tensorboard \
+    --log-batch-size-to-tensorboard \
+    --log-validation-ppl-to-tensorboard \
+```
+
+**CodeCarbon config**:
+
+```
+CODECARBON_PATH=$DATA_OUTPUT_PATH/codecarbon
+
+    --codecarbon-dir $CODECARBON_PATH \
+```
+
+
+
+**Training logs**
+
+All training logs are piped into `$six_ALL_CCFRSCRATCH/checkpoints/tr1-13B/logs/main_log.txt`.
+
+
+## Exporting
+
+Before starting training create cloned git repos to where output data will go.
+
+The last 4 should all be git repo clones
+```
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr1-13B
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints
+TENSORBOARD_PATH=$DATA_OUTPUT_PATH/tensorboard
+CODECARBON_PATH=$DATA_OUTPUT_PATH/codecarbon
+LOGS_PATH=$DATA_OUTPUT_PATH/logs
+```
+
+I created 4 repos at https://huggingface.co/bigscience/ and now we can clone those as the dirs data will be output into:
+
+```
+cd $six_ALL_CCFRSCRATCH/checkpoints/tr1-13B
+git clone https://huggingface.co/bigscience/tr1-13B-checkpoints checkpoints
+git clone https://huggingface.co/bigscience/tr1-13B-tensorboard tensorboard
+git clone https://huggingface.co/bigscience/tr1-13B-codecarbon codecarbon
+git clone https://huggingface.co/bigscience/tr1-13B-logs logs
+```
+
+If this is your first time running git-lfs on this system, you need to init it once:
+```
+module load git-lfs
+git lfs install
+```
+
+Most of the data types we are going to sync will be large or huge, and most are already lfs-tracked by default, so no setup is required. Except our log file which too can grow large, so we need to set it up:
+
+```
+cd logs
+git-lfs track *.txt
+git commit -m "large text files" .gitattributes
+git push
+```
+
+### Cronjobs to auto-sync the hub
+
+Now we just need a cronjob to automatically do for each type of data to export:
+
+```
+cd checkpoints
+git add */*.pt
+git commit -am "new data"
+git push
+```
+
+This job is performed automatically by `hub-sync.py`. For full details see: [Automated upload to the hub](../../data/export.md#automated-upload-to-the-hub).
+
+**Weights checkpoints**
+
+Currently, we aren't exporting checkpoints.
+
+**Tensorboard**
+
+Here is the slurm script to sync the tensorboard data: [tr1-13B-hub-sync-tensorboard.slurm](./tr1-13B-hub-sync-tensorboard.slurm)
+
+**CodeCarbon**
+
+Currently the feature is not enabled, so there is nothing to log.
+
+**Log of logs**
+
+Let's also create a log of logs. We will pipe all the logs in there and also the various status reports - e.g. while SLURM is queued the training and it's not running.
+
+Here is the slurm script to sync the raw logs data: [tr1-13B-hub-sync-logs.slurm](./tr1-13B-hub-sync-logs.slurm)
+
+The main source of logs is the training scripts. The logs are gathered via
+```
+$CMD ... 2>&1 | tee -a $LOGS_PATH/main_log.txt
+```
+in the training slurm script.
+
+XXX: we could also add various other diagnostics appended to the main log file. e.g. shared memory, etc.
+
+
+
+
+## Deepspeed config
+
+Using Deepspeed's activation checkpointing to use a lot less GPU memory
+
+```
+    --deepspeed-activation-checkpointing \
+```
+
+Possible extras:
+
+- Enabling `"contiguous_memory_optimization": true,` can help to reduce memory fragmentation, but it requiressetting `number_checkpoints`. This should be set to be equal to number of transformer blocks per pipeline stage times the number of pipeline parallel stage. Samyam says: Full disclaimer: I have only used this with ZeRO but not with pipeline parallelism. But by setting the number_checkpoints as described, it should work for PP too. The benefit of using it is usually only apparent when running very close to the memory limit.
+
+
+
+## Dataset
+
+- Full 304.2M version (529GB) : `$six_ALL_CCFRWORK/datasets-custom/oscar-en`
+- Tiny 10K version (56M): `$six_ALL_CCFRWORK/datasets-custom/oscar-en-10k`
+
+We are using English-only subset of [the OSCAR dataset](https://huggingface.co/datasets/oscar) with full documents (*not* individual sentences).
+
+We have about 300M records in 1.2TB of jsonl data (about 3/4 of which are smaller than 1K tokens), which amounts to about 280B tokens (estimated at about 4.5chars/word).
+
+Megatron's preprocessing tool indexes everything and then at training time the Dataloader serves chunks of the desired fixed sequence length (2048 tokens in our case).
+
+For more information on the pre-processing process and various estimations see: [OSCAR](../../data/oscar/README.md).
+
+
+
+## Dealing with 20h SLURM limit
+
+First, let's ensure we save a checkpoint just before SLURM kills the job
+
+Let's try 19:50 1190=60*20-10
+
+```
+    --exit-duration-in-mins 1190 \
+```
+
+For the bigger models 10min might not be long enoug to finish an iteration (assume the limit hits right as one starts) and write out a checkpoint.
+
+Then we need to figure out how to schedule the next slurm job as soon as the currently running one is over in 20h.
+
+We will use job arrays, to solve this. Let's start with just 10 such jobs:
+
+```
+sbatch --array=1-10%1 tr1-13B-round1.slurm
+```
+
+`%1` limits the number of simultaneously running tasks from this job array to 1, since we want them to run in a sequence.
+
+Alternatively, as always this param can be part of the script:
+```
+#SBATCH --array=1-10%1
+```
+
+## Crontab
+
+JZ doesn't have a user-accessible crontab facility, so we have to emulate it with a self-restarting slurm job that polls some dir for new jobs to run. For full details on how this works please see [Crontab Jobs](../../jz/crontab/).
+
+But to use it simply put your slurm scripts into either:
+```
+$six_ALL_CCFRWORK/cron/cron.hourly
+$six_ALL_CCFRWORK/cron/cron.daily
+```
+
+and the jobs will be run on hourly or daily basis. This is similar to Linux's `/etc/cron.*` setup. Except the jobs aren't guaranteed to start on the hour, but should be around that time.
+
+Currently we have:
+
+```
+ls -1 $six_ALL_CCFRWORK/cron/cron.hourly/*slurm
+tr1-13B-hub-sync-logs.slurm
+tr1-13B-hub-sync-tensorboard.slurm
+tr1-13B-slurm-status.slurm
+```
+
+The first 2 sync log files to the hub and the last one monitors the health of the training and alerts of any problems.
+
+
+## Estimated run time
+
+Best case scenario when training 24/7 on 64 nodes with 4 gpus each:
+```
+$ python -c 'Btokens=300; Bmodel=13; n_gpus=256; Tflops=45; \
+print(f"{Btokens*1e9*8*Bmodel*1e9/(n_gpus*Tflops*1e12*60*60*24):0.2f} days")'
+31.35 days
+```
+
+You will find the detailed explanation of the estimation formula [here](../../math/README.md#estimate-model-training-time).
+
+The training was much slower in the first 10k steps because of the batch size rampup, where the pipeline was very inefficient.
+
+And then we were only able to use 20h slurm jobs, with unpredictable gaps of wait time in between (1-30 hours!), so it's impossible to predict when the finish line will be finished.
+
+
+## Memory usage
+
+During training currently we use 256GB (8x 32GB gpus) per each full replica (TP=2 + PP=4), the rest are ZeRO-DP. So if we throw x times more GPUs we just speed things up by having more 2-node replicas.
+The required memory breakdown:
+
+1. 4B for fp32 weights
+2. 2B for fp16 weights
+3. 8B for optimizer states.
+4. 4B for gradients (we don't save these in the checkpoint)
+5. plus memory for activations and temps, which total majorly depends on the seqlen and mini batch size - and since we use activation checkpointing this memory need is quite small.
+
+Total: 234GB (18*13) plus activations and temps memory. So we are close to 256GB here.
+
+Activation memory would have been much much bigger if it weren't for activation checkpointing.
+
+
+## Checkpoint Back Up
+
+To copy multiple checkpoints excluding optimizer states. First move the desired checkpoints to back up to some dedicated dir, e.g. `tr1-13B-round2/checkpoints`, then copy just the needed files:
+
+```
+srun -p prepost  -A six@cpu --time=20:00:00 --pty bash
+mkdir to-upload
+rsync -acvhu --no-compress --info=progress2 --exclude "zero*pt" tr1-13B-round2/checkpoints/ to-upload
+```
+
+then to back those up:
+
+```
+cp -arun $six_ALL_CCFRSCRATCH/checkpoints/to-upload/* $six_ALL_CCFRSTORE/checkpoints/tr1-13B
+```
+
+
+**Final checkpoint with optimizer states:**
+
+```
+mkdir $six_ALL_CCFRSTORE/checkpoints/tr1-13B-with-optim
+cp -arun $six_ALL_CCFRSCRATCH/checkpoints/tr1-13B/checkpoints/global_step168000 $six_ALL_CCFRSTORE/checkpoints/tr1-13B-with-optim/
+```
+
+This is the final checkpoint, that can be resumed from at will:
+
+```
+$six_ALL_CCFRSTORE/checkpoints/tr1-13B-with-optim/global_step168000
+```
+
+Here is the corresponding log:
+```
+ iteration   168000/  311541 | consumed samples:    153013584 | elapsed time per iteration (ms): 13248.2 | learning rate: 1.000E-05 | global batch size:  1024 | lm loss: 2.376641E+00 | loss scale: 131072.0 | grad norm: 19767.052 | num zeros: 0.0 | number of skipped iterations:   0 | number of nan iterations:   0 |
+time (ms)
+--------------------------------------------------------------------------------------------------
+ validation loss at iteration 168000 | lm loss value: 2.342049E+00 | lm loss PPL: 1.040253E+01 |
+--------------------------------------------------------------------------------------------------
+```
+
+## Checkpoint Conversion and Upload
+
+
+**Important**: there was a bug in the converter on the transformers side, so we need this fix:
+https://github.com/huggingface/transformers/pull/13735
+if it's not merged yet, install this branch first. If it's already merged just make sure you use `transformers@master` - XXX: I will update the script to require a specific version once a new version of transformers is released.
+
+
+Open a long running interactive shell:
+```
+srun -p compil --cpus-per-task=40 -A six@cpu --time=6:00:00 --pty bash
+```
+then convert:
+
+```
+cd $six_ALL_CCFRSCRATCH/checkpoints/to-upload
+time find * -maxdepth 0 -type d -name "global_step*" -exec $six_ALL_CCFRWORK/code/Megatron-DeepSpeed/tools/convert_checkpoint/deepspeed_to_transformers.py --input_folder {} --output_folder hf-fixed/{} \;
+```
+
+It takes about 100sec per 26GB checkpoint.
+
+The results will be all under `hf/`.
+
+Now to uploading to the hub.
+
+Prepare the target dir:
+
+```
+#git -c http.extraHeader="Authorization: Basic " clone https://huggingface.co/bigscience/tr1-13B-checkpoints/
+
+cd tr1-13B-checkpoints
+
+
+huggingface-cli lfs-enable-largefiles .
+
+git config --unset user.email
+~/prod/code/bigscience/tools/hub-sync.py --repo-path . --patterns '*bogus*'
+```
+We are going to put each checkpoint into its own branch with the same name.
+
+```
+mv ../hf/global_step* .
+time find * -maxdepth 0 -type d -name "global_step*" -exec git checkout main \; -exec git checkout -b {} \; -exec git add {} \; -exec git commit -m "add {}" \; -exec git push --set-upstream origin {} \;
+git checkout main
+```
+
+Fixing up failed pushes / verifying that all pushes went through, re-pushing if needed
+
+```
+git branch | perl -lne 'm|(global_step\d+)| && print qx[git checkout $1; git push --set-upstream origin $1]'
+```
+
+If `git push` fails re-run with: `GIT_TRACE=1 GIT_TRANSFER_TRACE=1 GIT_CURL_VERBOSE=1 git push` to see what the actual error is.
+
+
+OK, the branch-per-checkpoint hub repo proved to be very difficult to upload and even more so using it after the upload.
+
+So let's try GCS bucket:
+
+```
+gcloud auth login
+gcloud config set project bigscience
+gsutil cp -r hf-fixed/* gs://bigscience-backups/tr1-13B/checkpoints/
+
+```
+or via rsync:
+```
+gsutil -m rsync -r hf-fixed/* gs://bigscience-backups/tr1-13B/checkpoints/
+```
+
+```
+start-prod
+cd /gpfsssd/scratch/rech/six/commun/checkpoints/to-upload/
+gsutil -m rsync -r hf-fixed1/* gs://bigscience-backups/tr1-13B/checkpoints/
+
+```
+
+or if needed to speed up the upload via multiple parallel copies open 2 `srun` instances and in one:
+```
+gsutil cp -r hf-fixed1/* gs://bigscience-backups/tr1-13B/checkpoints/
+```
+and in another:
+```
+gsutil cp -r hf-fixed2/* gs://bigscience-backups/tr1-13B/checkpoints/
+```
+
+can't use `rsync` with multiple sources - can only rsync a single dir.
+
+Later fixing `config.json` to include the correct `gelu_fast` activation correction and rsyncing the GCS bucket.
+
+(moved all the hf-fixed sub-dirs into a new folder `checkpoints`)
+
+```
+start-prod
+cd /gpfsssd/scratch/rech/six/commun/checkpoints/to-upload/
+perl -pi -e 's|gelu|gelu_fast|' checkpoints/*/config.json
+gsutil -m rsync -x ".*bin$" -r checkpoints gs://bigscience-backups/tr1-13B/checkpoints
+```
+this is really fast since we exclude the checkpoint files (`-x ".*bin$"`)
+
+
+## Other backups
+
+Logs:
+
+```
+mkdir $six_ALL_CCFRSTORE/checkpoints/tr1-13B-logs/
+tar -zcvf $six_ALL_CCFRSTORE/checkpoints/tr1-13B-logs/tensorboard.tgz $six_ALL_CCFRSCRATCH/checkpoints/tr1-13B/tensorboard
+tar -zcvf $six_ALL_CCFRSTORE/checkpoints/tr1-13B-logs/logs.tgz $six_ALL_CCFRSCRATCH/checkpoints/tr1-13B/logs
+```
+
+note: codecarbon wasn't ready during this training, so nothing to back up there.
+
+
+## Exports
+
+- GCS https://console.cloud.google.com/storage/browser/bigscience
+- The Hub https://huggingface.co/bigscience
+
+
+## Training scripts
+
+The training script is:
+
+- [tr1-13B-round1.slurm](./tr1-13B-round1.slurm)
+
+We also have:
+
+- [tr1-13B-short.slurm](./tr1-13B-short.slurm)
+
+which is a very small model to do quick testing and debug, but otherwise the same as the main script.
+
+The scripts are located at:
+
+```
+cd $six_ALL_CCFRWORK/code/tr1-13B/bigscience/train/tr1-13B-base
+```
+
+When no jobs are scheduled, currently we launch the main training script using:
+
+```
+sbatch --array=1-5%1 tr1-13B-round1.slurm
+```
+This will schedule 5 20h-trainings which will run one at a time, once the scheduler yields to the request, with unknown wait time in between each job.
+
+If there is a job running already, **do not use the above command** as we can't have 2 trainings overlap. If there is a training already running you can:
+
+1. either tell `sbatch` to start the new job once the currently running job succeeds, using:
+
+```
+sbatch --dependency=CURRENTLY_RUNNING_JOB_ID --array=1-5%1 tr1-13B-round1.slurm
+```
+
+Where `CURRENTLY_RUNNING_JOB_ID` is the job being reported running. For example if the report of the last job is:
+```
+[2021-08-16 22:08:01] tr1-13B-round3 is running for 18:15:59 since 2021-08-16T03:52:02 (711114_4 on 'gpu_p13' partition (r7i4n[1-7],r7i7n[1-8],r8i0n0,r8i5n[3-8],r8i6n[0-8],r9i0n8,r9i1n[0-8],r9i2n[7-8],r9i3n[0-8],r9i4n[0-8],r9i5n[0-2])
+```
+then the currently running job ID is `711114_4`. You can also gather the same info about the current scheduler status using `squeue`:
+
+```
+squeue --user=$(getent group six | cut -d: -f4) | grep tr1-13B
+```
+
+2. you could also see how much time is left before the current job finished (based on training log files) and then pass that many hours to `sbatch`. For example, if the job has **less** than 2 hours to run, but more than 1 hour, you want to launch it `now+2hours` from now:
+
+```
+sbatch --begin now+2hours --array=1-5%1 tr1-13B-round1.slurm
+```
+
+Using `--dependency` may lead to shorter wait times, since if the time passed to `--begin` allows even for a few minutes of delay since the stopping of the last job, the scheduler may already start some other jobs even if their priority is lower than our job. That's because the scheduler ignores any jobs with `--begin` until the specified time arrives.
+
+
+## On Call
+
+When a person is on call, they need to watch that the training is either running or scheduled to run. If neither is happening they need to schedule a new training. When this situation occurs the log file will report:
+
+```
+***ALERT: tr1-13B-round3.slurm is not RUNNING or SCHEDULED! Alert someone at Eng WG***
+```
+
+An email alert is sent as well to `[email protected]`.
+
+
+The next section explains how to watch the logs.
+
+
+Other than waiting for the watchdog which runs once an hour, one can immediately see if anything is scheduled with:
+
+```
+$six_ALL_CCFRWORK/code/tr1-13B/bigscience/tools/slurm-status.py --job-name tr1-13B-round3
+```
+
+If for some reason the training is not scheduled or running, to schedule a new training:
+
+```
+cd $six_ALL_CCFRWORK/code/tr1-13B/bigscience/train/tr1-13B-base
+sbatch --array=1-5%1 tr1-13B-round1.slurm
+```
+
+This will schedule a job array of 5 jobs of 20h each, so if all goes well, that's at least 4 days of not needing to do anything other than being on the lookout for potential crashes.
+
+XXX: need a troubleshooting section, but elsewhere in the document that is not this training specific.
+
+1. if one of the nodes gets a corrupted gpu, and the training crashes there is a risk that the next job in the training will get allocated the same node, in which case it'll crash again. We need a method to identify which node is corrupted, report that to [email protected] so they know to fix it and exclude this node from the slurm job by adding a list of nodes to exclude as following:
+
+```
+sbatch --exclude=r7i5n2,r7i5n6 ...
+```
+but we currently have no way to identify which node is faulty. I think if we switch to pt-1.9.0 or higher where torch elastic replaces the usual launcher. Or we have to use dedicated log files per node via: `#SBATCH --output=%x-%j-%N.out`.
+
+
+## Watching the training logs
+
+On JZ:
+```
+tail -f $six_ALL_CCFRSCRATCH/checkpoints/tr1-13B/logs/main_log.txt
+```
+
+Outside of JZ:
+```
+perl -e '$u=shift; $b=0; while(1){($e)=qx[curl -sI $u]=~/content-length: (\d+)/; \
+print qx[curl -sr $b-$e -L $u] if $e>$b; $b=$e; sleep 300}' \
+https://huggingface.co/bigscience/tr1-13B-logs/resolve/main/main_log.txt
+```
+Currently the updates happen hourly, so this is a delayed version of `tail -f`.
+
+
+## CodeCarbon
+
+
+CodeCarbon wasn't ready until the training was over so we only did an additional 10h run to measure with and the to extrapolate to the whole training.
+
+https://huggingface.co/bigscience/tr1-13B-codecarbon
+
+This set of records captures the startup time and 2499 iterations in 2 records per gpu, since there was also an intermediary checkpoint saved half-way and we flush the CC records on each checkpoint saving.
+
+The training had 168000 iterations. Therefore multiply the reported data by 67. This would be quite approximate since we were using 16 nodes when doing the ramp up, then 64 and only the last 3 weeks 128 nodes.
+
+Caveat emptor: I'm not sure whether CC-reports overlap since each report is per gpu and I think they may be measuring the same thing, other than the gpu itself. So this requires research.
+
+Each csv file contains a report for a single gpu/process. There are 512 reports.
+
+
+## Extras

train/tr1-13B-base/chronicles.md

@@ -0,0 +1,425 @@
+# tr1-13B Chronicles
+
+Notes on the training progress with a particular focus on any encountered problems and their diagnosis and solutions/prevention.
+
+To follow the training progress charts, see: [tensorboard](https://huggingface.co/bigscience/tr1-13B-tensorboard/tensorboard).
+
+To follow the raw training logs see: [logs](https://huggingface.co/bigscience/tr1-13B-logs/).
+
+
+## Round1 SAVE_INTERVAL=10
+
+NNODES=16
+
+saved checkpoint each 10 steps
+
+`$six_ALL_CCFRSCRATCH/checkpoints/tr1-13B/tr1-13B-round1/checkpoints`
+
+10 checkpoints (Every 10 steps 1-100) - 4TB
+
+## Round2 SAVE_INTERVAL=18
+
+NNODES=16
+
+moved the round1's checkpoints away
+
+rerun from scratch with the same seed
+
+saved checkpoint each 18 steps
+
+`$six_ALL_CCFRSCRATCH/checkpoints/tr1-13B/tr1-13B-round2/checkpoints`
+
+51 checkpoints (Every 18 steps 101-1000) - 20TB
+
+
+## Round3 SAVE_INTERVAL=1500 NNODES=16
+
+NNODES=16
+
+moved the round2's checkpoints away
+
+rerun from scratch with the same seed
+
+saved checkpoint each 1500 steps
+
+I did the full re-run because otherwise I couldn't separate the tensorboard logs - it is not possible to restart from a checkpoing using `TRAIN_ITER` or `EXIT_INTERVAL` which is not fixed.
+
+now we started uploading tensorboard logs
+
+
+## Round3 SAVE_INTERVAL=1500 NNODES=32
+
+Tried to switch to 64 nodes, but the training failed because GBS gets incremented by 16, which limits us to DP_SIZE=16 (with MBS=1) so we can do 32 nodes (128gpus at most).
+
+```
+DP_SIZE=$NNODES*$GPUS_PER_NODE/($PP_SIZE*$TP_SIZE)
+16     = 32*4/(4*2)
+```
+
+will switch to 64 nodes once GBS reaches 1024.
+
+
+The training then crashed with shared memory error after some 10h+ of training:
+```
+ERROR: Unexpected bus error encountered in worker. This might be caused by insufficient shared memory (shm).
+ERROR: Unexpected bus error encountered in worker. This might be caused by insufficient shared memory (shm).
+ERROR: Unexpected bus error encountered in worker. This might be caused by insufficient shared memory (shm).
+ERROR: Unexpected bus error encountered in worker. This might be caused by insufficient shared memory (shm).
+Traceback (most recent call last):
+  File "/gpfswork/rech/six/commun/conda/hf-prod/lib/python3.8/site-packages/torch/utils/data/dataloader.py", line 986, in _try_get_data
+Traceback (most recent call last):
+  File "/gpfswork/rech/six/commun/conda/hf-prod/lib/python3.8/site-packages/torch/utils/data/dataloader.py", line 986, in _try_get_data
+  File "/gpfswork/rech/six/commun/conda/hf-prod/lib/python3.8/queue.py", line 179, in get
+  File "/gpfswork/rech/six/commun/conda/hf-prod/lib/python3.8/queue.py", line 179, in get
+  File "/gpfswork/rech/six/commun/conda/hf-prod/lib/python3.8/threading.py", line 306, in wait
+  File "/gpfswork/rech/six/commun/conda/hf-prod/lib/python3.8/threading.py", line 306, in wait
+  File "/gpfswork/rech/six/commun/conda/hf-prod/lib/python3.8/site-packages/torch/utils/data/_utils/signal_handling.py", line 66, in handler
+  File "/gpfswork/rech/six/commun/conda/hf-prod/lib/python3.8/site-packages/torch/utils/data/_utils/signal_handling.py", line 66, in handler
+RuntimeError: DataLoader worker (pid 30882) is killed by signal: Bus error. It is possible that dataloader's workers are out of shared memory. Please try to raise your shared memory limit.
+RuntimeError
+The above exception was the direct cause of the following exception:
+: Traceback (most recent call last):
+DataLoader worker (pid 30801) is killed by signal: Bus error. It is possible that dataloader's workers are out of shared memory. Please try to raise your shared memory limit.  File "/gpfswork/rech/six/commun/code/Megatron-DeepSpeed/pretrain_gpt.py", line 215, in <module>
+The above exception was the direct cause of the following exception:
+Traceback (most recent call last):
+  File "/gpfswork/rech/six/commun/code/Megatron-DeepSpeed/pretrain_gpt.py", line 215, in <module>
+    pretrain(train_valid_test_datasets_provider, model_provider, forward_step,
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/Megatron-DeepSpeed/megatron/training.py", line 144, in pretrain
+    pretrain(train_valid_test_datasets_provider, model_provider, forward_step,
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/Megatron-DeepSpeed/megatron/training.py", line 144, in pretrain
+        iteration = train(forward_step_func,iteration = train(forward_step_func,
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/Megatron-DeepSpeed/megatron/training.py", line 675, in train
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/Megatron-DeepSpeed/megatron/training.py", line 675, in train
+    train_step(forward_step_func,
+    train_step(forward_step_func,  File "/gpfsssd/worksf/projects/rech/six/commun/code/Megatron-DeepSpeed/megatron/training.py", line 381, in train_step
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/Megatron-DeepSpeed/megatron/training.py", line 381, in train_step
+    loss = model[0].train_batch(data_iter=data_iterator)
+loss = model[0].train_batch(data_iter=data_iterator)
+```
+
+Each node has 94GB of /dev/shm, so it's very strange that this happened.
+
+```
+df -h | grep shm
+tmpfs            94G  336K   94G   1% /dev/shm
+```
+This is after 2h of training on one node. I wonder if the problem was on some specific node.
+
+Though Remi checked that all nodes used by the training that crashed had this exact setup. And all reported %1 usage.
+
+
+
+To continually diagnose the running nodes's shm memory usage:
+```
+for ((;;)) { (srun --jobid 637799 --gres=gpu:0 $six_ALL_CCFRWORK/bin/report_shm_usage | grep -v "1%"); sleep 10; }
+```
+after adjusting the jobid number.
+
+where:
+```
+cat $six_ALL_CCFRWORK/bin/report_shm_usage
+#!/usr/bin/bash
+
+# print shared memory usage with the host
+
+echo $(hostname) $(df -h | grep /dev/shm)
+```
+
+The shared memory is used by `DataLoader` workers. We just use the default `args.num_workers==2` and 94GB of shm available on each node is a huge amount of shared memory.
+
+And given that we use TP+PP, a single node doesn't have DDP on it, so no multiproc on the local host. Currently one full model replica uses 2 full nodes (`TP*PP = 2*4 = 8`) So it's really a single Dataloader call per each 2 nodes. i.e. tiny tiny needs.
+
+If this happens again, setting `args.num_workers==0` will stop using shared memory, but it'll impact the data loading speed.
+
+Jared hasn't seen this problem in his experience.
+
+So at the moment we don't know what happened.
+
+2 more 20h trainings have been run since then w/o any problems.
+
+## Checking the progress
+
+Someone asked when the current training will complete:
+
+Let's do math:
+
+1. we are currently going at 784 samples in 32 seconds, or 24.5 samples / sec
+2. roughly we have 145M samples to go, so at the current speed 32nodes if we manage to have 20h allocation every 24 hours we get about 82 days. (145_000_000/(20*60*60*24.5))
+3. we should reach GBS=1024 hopefully today and then we can crank up to 64nodes, which should roughly double the speed, so it'll take 41 days to complete if all goes well and we don't sit in the queue for more than 4 hours.
+4. we can dare to try 128 nodes, which would quadruple the speed and we should be done in about 20 days. It's hard to tell how quickly the SLURM scheduler will provide such a large allocation - if more than half-day of wait time, we are probably better off with 64 nodes.
+
+
+## Round3 SAVE_INTERVAL=1500 NNODES=64
+
+Finally GBS is at 1024, so we can do 64 nodes. Clocking about 23-26 secs / iteration - the performance jumps around quite a lot from run to run. But we know that already about JZ - it's very unsteady and depends on network usage by others.
+
+Created a dedicated branch `tr1-13B`, which allows further development w/o the risk of breaking the current training.
+
+## A huge lm loss spike
+
+The training loss just jumped from ~3 to ~9
+```
+ iteration    29020/  311541 | consumed samples:     10698064 | elapsed time per iteration (ms): 22306.6 | learning rate: 9.850E-05 | global batch size:  1024 | lm loss: 2.775923E+00 | loss scale: 32768.0 | grad norm: 0.000 | num zeros: 0.0 | number of skipped iterations:   0 | number of nan iterations:   0 |
+time (ms)
+ iteration    29030/  311541 | consumed samples:     10708304 | elapsed time per iteration (ms): 22336.4 | learning rate: 9.849E-05 | global batch size:  1024 | lm loss: 2.772822E+00 | loss scale: 32768.0 | grad norm: 0.000 | num zeros: 0.0 | number of skipped iterations:   0 | number of nan iterations:   0 |
+time (ms)
+ iteration    29040/  311541 | consumed samples:     10718544 | elapsed time per iteration (ms): 22332.6 | learning rate: 9.849E-05 | global batch size:  1024 | lm loss: 2.768131E+00 | loss scale: 65536.0 | grad norm: 0.000 | num zeros: 0.0 | number of skipped iterations:   0 | number of nan iterations:   0 |
+time (ms)
+ iteration    29050/  311541 | consumed samples:     10728784 | elapsed time per iteration (ms): 22148.5 | learning rate: 9.849E-05 | global batch size:  1024 | lm loss: 7.343709E+00 | loss scale: 8192.0 | grad norm: 0.000 | num zeros: 0.0 | number of skipped iterations:   0 | number of nan iterations:   0 |
+time (ms)
+ iteration    29060/  311541 | consumed samples:     10739024 | elapsed time per iteration (ms): 22181.7 | learning rate: 9.849E-05 | global batch size:  1024 | lm loss: 8.715872E+00 | loss scale: 4096.0 | grad norm: 0.000 | num zeros: 0.0 | number of skipped iterations:   0 | number of nan iterations:   0 |
+time (ms)
+ iteration    29070/  311541 | consumed samples:     10749264 | elapsed time per iteration (ms): 22107.1 | learning rate: 9.848E-05 | global batch size:  1024 | lm loss: 7.654131E+00 | loss scale: 4096.0 | grad norm: 0.000 | num zeros: 0.0 | number of skipped iterations:   0 | number of nan iterations:   0 |
+time (ms)
+ iteration    29080/  311541 | consumed samples:     10759504 | elapsed time per iteration (ms): 22131.2 | learning rate: 9.848E-05 | global batch size:  1024 | lm loss: 7.192470E+00 | loss scale: 4096.0 | grad norm: 0.000 | num zeros: 0.0 | number of skipped iterations:   0 | number of nan iterations:   0 |
+time (ms)
+ iteration    29090/  311541 | consumed samples:     10769744 | elapsed time per iteration (ms): 22119.2 | learning rate: 9.848E-05 | global batch size:  1024 | lm loss: 6.849044E+00 | loss scale: 4096.0 | grad norm: 0.000 | num zeros: 0.0 | number of skipped iterations:   0 | number of nan iterations:   0 |
+```
+
+You can see the spike at https://huggingface.co/bigscience/tr1-13B-tensorboard/tensorboard
+
+It took some 500 iterations to recover.
+
+There was a second spike a bit later, half the first one this time and recovered very quickly.
+
+We discussed why it may have happened, but we don't have any definitive answer.
+
+
+## Checkpoint bloat issue
+
+We have an issue with per-layer checkpoints that are way bigger than they should be. They are 10x bigger than what they should be. After some research we discovered that `torch.save()` doesn't save the current view, but the whole tensor with its original tensor storage. So that's why were were getting 10x bigger files than the actual data in the per-layer checkpoints.
+
+We need to `.clone()` the tensors before saving them. and then the checkpoint for layers is just modelsize*2 bytes. The reason they were bloated is because ZeRO-1 pre-allocated large tensor buffers for run-time optimization. So this needs to be fixed in Deepspeed's pipe checkpoing saving.
+
+Also will write a script to fix the already-saved checkpoints to `clone` and re-save.
+
+
+## old NCCL
+
+Discovered the NCCL was statically linked into the distributed pytorch and it's really old 2.7.9. Supposedly newer NCCL should help with OPA interlink performance. But that means we either need to switch to a more recent pytorch or build our own. This is not resolved yet.
+
+
+## Watchdog
+
+We created a watchdog, that reports if we are running/scheduled and alerts if neither is happening. E.g. the recent log in the main log file was:
+
+```
+ iteration    33240/  311541 | consumed samples:     15019344 | elapsed time per iteration (ms): 23491.4 | learning rate: 9.702E-05 | global batch size:  1024 | lm loss: 2.722675E+00 | loss scale: 32768.0 | grad norm: 0.000 | num zeros: 0.0 | number of skipped iterations:   0 | number of nan iterations:   0 |
+time (ms)
+saving checkpoint at iteration   33241 to /gpfsscratch/rech/six/commun/checkpoints/tr1-13B/checkpoints
+[2021-08-08 01:00:44,221] [INFO] [logging.py:68:log_dist] [Rank 0] Saving model checkpoint: /gpfsscratch/rech/six/commun/checkpoints/tr1-13B/checkpoints/global_step33241/mp_rank_00_model_states.pt
+  successfully saved checkpoint at iteration   33241 to /gpfsscratch/rech/six/commun/checkpoints/tr1-13B/checkpoints
+time (ms) | save-checkpoint: 57514.53
+[exiting program after 1190.0357275923093 minutes] datetime: 2021-08-08 01:00:51
+[2021-08-08 01:49:40] ***ALERT: tr1-13B-round3.slurm is not RUNNING or SCHEDULED! Alert someone at Eng WG***
+[2021-08-08 02:49:44] ***ALERT: tr1-13B-round3.slurm is not RUNNING or SCHEDULED! Alert someone at Eng WG***
+[2021-08-08 03:56:54] tr1-13B-round3 is scheduled to start in 3 days, 7:24:19 (at 2021-08-11T11:21:14) (682842_[1-5%1] on 'gpu_p13' partition)
+```
+
+## NNODES=96
+
+We thoughts that trying more nodes would be a good idea, but 96 nodes proved to be unacceptable, since
+
+GBS=1024 is not divisible by 384 (96*4), so there is no way to spread data evenly across all replicas.
+
+We can only have either 256, 512 or 1024 gpus (64, 128, 256 nodes)
+
+## Corrupt GPU crashes the training multiple times
+
+One of the array job trainings crashes after many hours of training:
+
+```
+iteration    43680/  311541 | consumed samples:     25709904 | elapsed time per iteration (ms): 25593.4 | learning rate: 9.135E-05 | global batch size:  1024 | lm loss: 2.635663E+00 | loss scale: 131072.0 | grad norm: 17224.723 | num zeros: 0.0 | number of skipped iterations:   0 | number of nan iterations:   0 |
+time (ms)
+Traceback (most recent call last):
+  File "/gpfswork/rech/six/commun/code/tr1-13B/Megatron-DeepSpeed-tr1-13B/pretrain_gpt.py", line 222, in <module>
+    pretrain(train_valid_test_datasets_provider, model_provider, forward_step,
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/tr1-13B/Megatron-DeepSpeed-tr1-13B/megatron/training.py", line 144, in pretrain
+    iteration = train(forward_step_func,
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/tr1-13B/Megatron-DeepSpeed-tr1-13B/megatron/training.py", line 677, in train
+    train_step(forward_step_func,
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/tr1-13B/Megatron-DeepSpeed-tr1-13B/megatron/training.py", line 381, in train_step
+    loss = model[0].train_batch(data_iter=data_iterator)
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/tr1-13B/DeepSpeed-big-science/deepspeed/runtime/pipe/engine.py", line 291, in train_batch
+    self._exec_schedule(sched)
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/tr1-13B/DeepSpeed-big-science/deepspeed/runtime/pipe/engine.py", line 1237, in _exec_schedule
+    self._exec_instr(**cmd.kwargs)
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/tr1-13B/DeepSpeed-big-science/deepspeed/runtime/pipe/engine.py", line 679, in _exec_backward_pass
+    torch.autograd.backward(tensors=(outputs, ), grad_tensors=(grad_tensors, ))
+  File "/gpfswork/rech/six/commun/conda/tr1-13B/lib/python3.8/site-packages/torch/autograd/__init__.py", line 145, in backward
+    Variable._execution_engine.run_backward(
+RuntimeError: transform: failed to synchronize: cudaErrorECCUncorrectable: uncorrectable ECC error encountered
+terminate called after throwing an instance of 'c10::Error'
+  what():  CUDA error: uncorrectable ECC error encountered
+Exception raised from create_event_internal at /opt/conda/conda-bld/pytorch_1616554793803/work/c10/cuda/CUDACachingAllocator.cpp:733 (most recent call first):
+frame #0: c10::Error::Error(c10::SourceLocation, std::string) + 0x42 (0x1500fb4d42f2 in /gpfswork/rech/six/commun/conda/tr1-13B/lib/python3.8/site-packages/torch/lib/libc10.so)
+frame #1: c10::detail::torchCheckFail(char const*, char const*, unsigned int, std::string const&) + 0x5b (0x1500fb4d167b in /gpfswork/rech/six/commun/conda/tr1-13B/lib/python3.8/site-packages/torch/lib/libc10.so)
+frame #2: c10::cuda::CUDACachingAllocator::raw_delete(void*) + 0x809 (0x1500fb72d219 in /gpfswork/rech/six/commun/conda/tr1-13B/lib/python3.8/site-packages/torch/lib/libc10_cuda.so)
+frame #3: c10::TensorImpl::release_resources() + 0x54 (0x1500fb4bc3a4 in /gpfswork/rech/six/commun/conda/tr1-13B/lib/python3.8/site-packages/torch/lib/libc10.so)
+frame #4: <unknown function> + 0x6e0e5a (0x150152432e5a in /gpfswork/rech/six/commun/conda/tr1-13B/lib/python3.8/site-packages/torch/lib/libtorch_python.so)
+frame #5: <unknown function> + 0x6e0ef1 (0x150152432ef1 in /gpfswork/rech/six/commun/conda/tr1-13B/lib/python3.8/site-packages/torch/lib/libtorch_python.so)
+frame #6: <unknown function> + 0x1a6b5a (0x56434fce9b5a in /gpfswork/rech/six/commun/conda/tr1-13B/bin/python)
+frame #7: <unknown function> + 0x110b7c (0x56434fc53b7c in /gpfswork/rech/six/commun/conda/tr1-13B/bin/python)
+frame #8: <unknown function> + 0x1105b9 (0x56434fc535b9 in /gpfswork/rech/six/commun/conda/tr1-13B/bin/python)
+frame #9: <unknown function> + 0x1105a3 (0x56434fc535a3 in /gpfswork/rech/six/commun/conda/tr1-13B/bin/python)
+frame #10: <unknown function> + 0x1105a3 (0x56434fc535a3 in /gpfswork/rech/six/commun/conda/tr1-13B/bin/python)
+frame #11: <unknown function> + 0x177917 (0x56434fcba917 in /gpfswork/rech/six/commun/conda/tr1-13B/bin/python)
+frame #12: PyDict_SetItemString + 0x4c (0x56434fcbd86c in /gpfswork/rech/six/commun/conda/tr1-13B/bin/python)
+frame #13: PyImport_Cleanup + 0xac (0x56434fd2f0ec in /gpfswork/rech/six/commun/conda/tr1-13B/bin/python)
+frame #14: Py_FinalizeEx + 0x79 (0x56434fd95589 in /gpfswork/rech/six/commun/conda/tr1-13B/bin/python)
+frame #15: Py_RunMain + 0x1bc (0x56434fd988fc in /gpfswork/rech/six/commun/conda/tr1-13B/bin/python)
+frame #16: Py_BytesMain + 0x39 (0x56434fd98ce9 in /gpfswork/rech/six/commun/conda/tr1-13B/bin/python)
+frame #17: __libc_start_main + 0xf3 (0x150183467873 in /lib64/libc.so.6)
+frame #18: <unknown function> + 0x1f7847 (0x56434fd3a847 in /gpfswork/rech/six/commun/conda/tr1-13B/bin/python)
+```
+
+Nobody was around to notice and slurm scheduler started the next training job in the array, and it crashed too this time right away on:
+
+```
+> initializing tensor model parallel with size 2
+> initializing pipeline model parallel with size 4
+> setting random seeds to 42 ...
+[2021-08-12 08:19:28,225] [INFO] [checkpointing.py:226:model_parallel_cuda_manual_seed] > initializing model parallel cuda seeds on global rank 0, model parallel rank 0, and data parallel rank 0 with model parallel seed: 2760 and data parallel seed: 42
+> compiling dataset index builder ...
+make: Entering directory '/gpfsssd/worksf/projects/rech/six/commun/code/tr1-13B/Megatron-DeepSpeed-tr1-13B/megatron/data'
+make: Nothing to be done for 'default'.
+make: Leaving directory '/gpfsssd/worksf/projects/rech/six/commun/code/tr1-13B/Megatron-DeepSpeed-tr1-13B/megatron/data'
+>>> done with dataset index builder. Compilation time: 0.338 seconds
+> compiling and loading fused kernels ...
+Traceback (most recent call last):
+  File "/gpfswork/rech/six/commun/code/tr1-13B/Megatron-DeepSpeed-tr1-13B/pretrain_gpt.py", line 222, in <module>
+    pretrain(train_valid_test_datasets_provider, model_provider, forward_step,
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/tr1-13B/Megatron-DeepSpeed-tr1-13B/megatron/training.py", line 95, in pretrain
+    initialize_megatron(extra_args_provider=extra_args_provider,
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/tr1-13B/Megatron-DeepSpeed-tr1-13B/megatron/initialize.py", line 89, in initialize_megatron
+    _compile_dependencies()
+  File "/gpfsssd/worksf/projects/rech/six/commun/code/tr1-13B/Megatron-DeepSpeed-tr1-13B/megatron/initialize.py", line 140, in _compile_dependencies
+    torch.distributed.barrier()
+  File "/gpfswork/rech/six/commun/conda/tr1-13B/lib/python3.8/site-packages/torch/distributed/distributed_c10d.py", line 2420, in barrier
+    work = default_pg.barrier(opts=opts)
+RuntimeError: CUDA error: out of memory
+```
+
+We figured one of the gpus had a hardware problem. So it crashed the first time. And then the scheduler allocated the same node and of course, we crashed again.
+
+We contacted JZ admins and indeed one of the nodes was faulty. The next training didn't hit this node and the training continued.
+
+Unfortunately we currently don't have a way to correlate the exceptions to the hostname of the node that it happened on. It's really to have this feature available, since if we don't, we can keep on hitting the faulty node and it'll continue crashing the training. If we know the node's hostname we can exclude it from the `sbatch --exclude=node1,node2,... `.
+
+update: At the moment we have to add `%N` to `#SBATCH --output=%x-%j-%N.out` and then each node will have is own log file and then we can tell which node has a corrupt GPU.
+
+## Really long wait time to get allocation
+
+When a job gets queued we often see 3 days expected wait time before yielding, but most of the time the job comes through in several hours. Sometimes we have to wait for a really long time, like 30h, with scheduler bumping our job down multiple times. This is a big problem as it pushes the finish line away continuously. We aren't anywhere close to being able to train 24/7 despite having many hours allocated to us for this project.
+
+Another problem is that within a project we don't have a way to give the main training job a higher priority than other jobs that we run in parallel on various experiments and small trainings. There really should be a way for a user to say, this is a high priority job amongst all other jobs of the same group. But we didn't find a way to do that.
+
+## Test suite added
+
+A `Megatron-Deepspeed` test suite was finally added. It was odd Megatron-LM didn't have one in the first place, so we had to create our own.
+
+Now need to find some hardware with 2 gpus to create a CI.
+
+## Reduced evaluation iterations
+
+Noticed that somehow it was configured to run eval for 100 iterations, after discussion reduced it to 5, thus saving some resources. While validation iterations are much faster than training, this wasn't really needed.
+
+## NNODES=128
+
+Taking advantage of August's holiday in France was able to switch to 128 nodes.
+
+Observed a further drop in TFLOPs, since now we had even less microbatches to go around. This is because Global BS remained the same (GBS=1024) and we currently use 2 nodes for a single replica (TP=2 * TP=4). So with 128 nodes, we have 64 replicas, which leaves only GAS=16 per replica, and that's too little for an efficient pipeline. The idle bubble is too big.
+
+The benchmarking/tune up was done with GAS=128 (GBS=1024/8) and that's where we were getting high TFLops.
+
+Nevertheless, the training is going much faster now and we will catch up lost time quickly.
+
+## NCCL experiments
+
+It was suggested that newer NCCL will lead to faster inter-node communication.
+
+
+hypothesis that newer nccl should be faster on JZ, but the short experiments I run didn't support it. I get the same throughput with:
+
+1. pt=1.8.1, cuda=11.1, nccl=2708
+2. pt=1.9.0, cuda=11.1, nccl=2708
+3. pt=1.10.0.dev20210821, cuda=11.3, nccl=(2, 10, 3)
+
+The experiment was run on the same 4-node allocation with GBS=64, but otherwise everything else was the same as the current training script. The speed was 17-17.5 secs per iteration. Did about 100 iterations.
+So we will stick to pt=1.8.1 for now until a need arises to change that.
+
+## SLURM Job Arrays and Dependency
+
+Switched to using SLURM Job Arrays and Dependency to schedule jobs. Since our account has a huge allocation we were able to start new 20h jobs with no delay.
+
+If this approach is not used even a tiny delay between finishing one job and scheduling the next one often lead to 1-30 hours of wait time in the queue. This is because the scheduler was quick to allocate other jobs in the first few seconds of finishing the currently running job.
+
+The problem remained if something goes wrong - e.g. a mistake in a script or some hardware issue, would lead to a delay in staring new jobs and a long long wait time.
+
+This training was getting its software updated a lot as missing features were added, so it wasn't a super-stable polished production environment.
+
+So as long as we had a stable setup using SLURM Job Arrays and Dependency chaining things went well. When we couldn't use those SLURM was delaying our training sometimes by a lot.
+
+Also since we run secondary trainings we learned to use `--nice=10000` for those trainings. Without this method all slurm jobs of the same account had the same priority.
+
+## Added an alert email notification
+
+Previously implemented watchdog now got hooked up to email notifications, so if it detected that no job was running or scheduled it'd let the group know.
+
+## Checkpoint bloat fixed
+
+The Deepspeed team fixed the bloat in the checkpoints, so new checkpoints were taking 10x less space for layer weights.
+
+I then processed all the old checkpoints to remove the bloat using:
+
+```
+srun -p prepost  -A six@cpu --time=20:00:00 --pty bash
+wget https://raw.githubusercontent.com/stas00/toolbox/master/pytorch/pt-checkpoint-shrink.py
+chmod a+x pt-checkpoint-shrink.py
+cd checkpoints
+find -type d -name "global_step*" -exec pt-checkpoint-shrink.py --checkpoint_dir {} --patterns "layer*pt" \;
+```
+
+## CI was added
+
+A CI was implemented using EC2 instance on demand. With the help of https://github.com/machulav/ec2-github-runner
+
+Eventually it proved to be not usable for PRs made from the forks, as EC2 needs secrets that github actions won't give to PRs not originating from the origin. So this CI is not very useful.
+
+
+## Training completed
+
+On Sep 6th we reached the 300B tokens and on Sep 7th we stopped the training - It took some ~5 weeks to complete.
+
+
+## Checkpoint conversion
+
+We still need to figure out how to make the checkpoint available in the HF `transformers` format. This is a work in progress.
+
+Update: This has been done. All checkpoints converted to HF format and uploaded to HUB.
+
+See [README.md](README.md) for nuances of the conversion.
+
+Made a mistake in the activation function setting when writing the HF model after the conversion. It proved to be a complex situation but it needs to be `gelu_fast` on the HF side since we are using `args.openai_gelu = False; args.bias_gelu_res = True`. So applied fixes to the models on the HUB using the following:
+
+```
+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
+```
+Note using the trick of not checkout out LFS files since we only need to modify `config.json` which is a normal file - this is thousands times faster than normal checkout.
+
+
+
+and for GCS:
+```
+start-prod
+cd /gpfsssd/scratch/rech/six/commun/checkpoints/to-upload/
+perl -pi -e 's|gelu|gelu_fast|' checkpoints/*/config.json
+gsutil -m rsync -x ".*bin$" -r checkpoints gs://bigscience-backups/tr1-13B/checkpoints
+```

train/tr1-13B-base/start-tr1-13B

@@ -0,0 +1,57 @@
+# This is a python production script for JZ / tr1-13B training
+#
+# Activate with:
+#
+# source ./start-tr1-13B
+#
+#
+
+# # 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-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 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 tr1-13B

train/tr1-13B-base/tr1-13B-hub-sync-logs.slurm

@@ -0,0 +1,23 @@
+#!/bin/bash
+#SBATCH --job-name=tr1-13B-hub-sync-logs  # job name
+#SBATCH --ntasks=1                   # number of MP tasks
+#SBATCH --nodes=1                    # number of nodes
+#SBATCH --cpus-per-task=1            # number of cores per task
+#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
+
+echo "START TIME: $(date)"
+
+source $six_ALL_CCFRWORK/code/tr1-13B/bigscience/train/tr1-13B-base/start-tr1-13B
+module load git-lfs
+
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr1-13B
+LOGS_PATH=$DATA_OUTPUT_PATH/logs
+BIG_SCIENCE_REPO_PATH=$six_ALL_CCFRWORK/code/tr1-13B/bigscience
+
+$BIG_SCIENCE_REPO_PATH/tools/hub-sync.py --repo-path $LOGS_PATH --patterns '*.txt' -d
+
+echo "END TIME: $(date)"

train/tr1-13B-base/tr1-13B-hub-sync-tensorboard.slurm

@@ -0,0 +1,23 @@
+#!/bin/bash
+#SBATCH --job-name=tr1-13B-hub-sync-tensorboard  # job name
+#SBATCH --ntasks=1                   # number of MP tasks
+#SBATCH --nodes=1                    # number of nodes
+#SBATCH --cpus-per-task=1            # number of cores per task
+#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
+
+echo "START TIME: $(date)"
+
+source $six_ALL_CCFRWORK/code/tr1-13B/bigscience/train/tr1-13B-base/start-tr1-13B
+module load git-lfs
+
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr1-13B
+TENSORBOARD_PATH=$DATA_OUTPUT_PATH/tensorboard
+BIG_SCIENCE_REPO_PATH=$six_ALL_CCFRWORK/code/tr1-13B/bigscience
+
+$BIG_SCIENCE_REPO_PATH/tools/hub-sync.py --repo-path $TENSORBOARD_PATH --patterns '*tfevents*' -d
+
+echo "END TIME: $(date)"

train/tr1-13B-base/tr1-13B-round1.slurm

@@ -0,0 +1,174 @@
+#!/bin/bash
+#SBATCH --job-name=tr1-13B-round3
+#SBATCH --constraint=v100-32g
+#SBATCH --nodes=128
+#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 --account=six@v100
+
+set -x -e
+
+source $six_ALL_CCFRWORK/code/tr1-13B/bigscience/train/tr1-13B-base/start-tr1-13B
+
+echo "START TIME: $(date)"
+
+#ROUND=3
+
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr1-13B
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints
+TENSORBOARD_PATH=$DATA_OUTPUT_PATH/tensorboard
+CODECARBON_PATH=$DATA_OUTPUT_PATH/codecarbon
+LOGS_PATH=$DATA_OUTPUT_PATH/logs
+
+MEGATRON_DEEPSPEED_REPO=$six_ALL_CCFRWORK/code/tr1-13B/Megatron-DeepSpeed-tr1-13B/
+
+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
+
+cd $MEGATRON_DEEPSPEED_REPO
+
+MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)
+MASTER_PORT=6000
+
+GPUS_PER_NODE=4
+NNODES=128   # switch to 128
+TP_SIZE=2    # always fixed to the size of a single node
+PP_SIZE=4    # NLAYERS must be a multiple of PP_SIZE here
+#DP_SIZE=$NNODES*$GPUS_PER_NODE/($PP_SIZE*$TP_SIZE) # will get derived automatically by trainer
+
+# GLOBAL_BATCH_SIZE has to be divisible by MICRO_BATCH_SIZE*DP_size
+# GLOBAL_BATCH_SIZE=$(($MICRO_BATCH_SIZE*$GAS*$DP_SIZE)) - GAS is auto-derived by deepspeed
+MICRO_BATCH_SIZE=1
+GLOBAL_BATCH_SIZE=1024
+
+NLAYERS=40
+NHIDDEN=5120
+NHEADS=32
+FFN_HIDDEN_SIZE=20480
+SEQ_LEN=2048
+VOCAB_SIZE=50257
+
+SAVE_INTERVAL=1500
+
+OPTIMIZER_ARGS=" \
+    --optimizer adam \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.999 \
+    --adam-eps 1e-8 \
+    --lr 1e-4 \
+    --min-lr 1e-5 \
+    --lr-decay-style cosine \
+    --lr-decay-samples 126_953_125 \
+    --lr-warmup-samples 216_320 \
+    --clip-grad 1.0 \
+    --weight-decay 1e-1 \
+    "
+
+EXIT_OPTS=" \
+    --exit-duration-in-mins 1190 \
+    "
+
+GPT_ARGS=" \
+    --num-layers $NLAYERS \
+    --hidden-size $NHIDDEN \
+    --ffn-hidden-size $FFN_HIDDEN_SIZE \
+    --num-attention-heads $NHEADS \
+    --seq-length $SEQ_LEN \
+    --max-position-embeddings $SEQ_LEN \
+    --micro-batch-size $MICRO_BATCH_SIZE \
+    --rampup-batch-size 16 16 5_000_000 \
+    --global-batch-size $GLOBAL_BATCH_SIZE \
+    --train-samples 300_000_000 \
+    --vocab-file $VOCAB_FILE \
+    --merge-file $MERGE_FILE \
+    --loss-scale 12 \
+    --clip-grad 1.0 \
+    --fp16 \
+    --checkpoint-activations \
+    --seed 42
+    $OPTIMIZER_ARGS \
+    $EXIT_OPTS \
+    "
+
+OUTPUT_ARGS=" \
+    --log-interval 10 \
+    --save-interval $SAVE_INTERVAL \
+    --eval-interval 1000 \
+    --eval-iters 5 \
+    --codecarbon-dir $CODECARBON_PATH \
+    --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.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 \
+    "
+
+echo $CMD
+
+# to debug - add echo (it exits and prints what it would have launched)
+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/tr1-13B-base/tr1-13B-short.slurm

@@ -0,0 +1,189 @@
+#!/bin/bash
+#SBATCH --job-name=tr1-13B-short
+#SBATCH --constraint=v100-32g
+#SBATCH --nodes=2
+#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 --account=six@v100
+
+
+
+# This is the same as the main script but pre-configured for a small model that can be easily tested
+# on 1 or 2 nodes, which is handy to verify everything works before using it on the main training.
+#
+# It's also useful for pre-building megatron CUDA kernels if and when things get borked and it gets stuck in building kernels.
+#
+# Change to NNODES=1 if needed
+#
+# to allocate (change to 2 for NNODES=2)
+# salloc --constraint=v100-32g --account=six@v100 --nodes=1 --ntasks=1 --cpus-per-task=40 --gres=gpu:4 --hint=nomultithread --time=6:00:00 bash
+
+source $six_ALL_CCFRWORK/code/tr1-13B/bigscience/train/tr1-13B-base/start-tr1-13B
+
+set -x -e
+
+echo "START TIME: $(date)"
+
+#ROUND=3
+
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr1-13B-test
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints
+TENSORBOARD_PATH=$DATA_OUTPUT_PATH/tensorboard
+CODECARBON_PATH=$DATA_OUTPUT_PATH/codecarbon
+LOGS_PATH=$DATA_OUTPUT_PATH/logs
+
+MEGATRON_DEEPSPEED_REPO=$six_ALL_CCFRWORK/code/tr1-13B/Megatron-DeepSpeed-tr1-13B/
+
+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
+
+cd $MEGATRON_DEEPSPEED_REPO
+
+MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)
+MASTER_PORT=6000
+
+GPUS_PER_NODE=4
+NNODES=2    # switch to 64
+TP_SIZE=2    # always fixed to the size of a single node
+PP_SIZE=2    # NLAYERS must be a multiple of PP_SIZE here
+#DP_SIZE=$NNODES*$GPUS_PER_NODE/($PP_SIZE*$TP_SIZE) # will get derived automatically by trainer
+
+# GLOBAL_BATCH_SIZE has to be divisible by MICRO_BATCH_SIZE*DP_size
+# GLOBAL_BATCH_SIZE=$(($MICRO_BATCH_SIZE*$GAS*$DP_SIZE)) - GAS is auto-derived by deepspeed
+MICRO_BATCH_SIZE=1
+GLOBAL_BATCH_SIZE=64
+
+NLAYERS=8
+NHIDDEN=512
+NHEADS=8
+FFN_HIDDEN_SIZE=2048
+SEQ_LEN=512
+VOCAB_SIZE=50257
+
+SAVE_INTERVAL=2000
+
+
+OPTIMIZER_ARGS=" \
+    --optimizer adam \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.999 \
+    --adam-eps 1e-8 \
+    --lr 1e-4 \
+    --min-lr 1e-5 \
+    --lr-decay-style cosine \
+    --lr-decay-samples 126_953_125 \
+    --lr-warmup-samples 216_320 \
+    --clip-grad 1.0 \
+    --weight-decay 1e-1 \
+    "
+
+EXIT_OPTS=" \
+    --exit-duration-in-mins 1190 \
+    "
+
+GPT_ARGS=" \
+    --num-layers $NLAYERS \
+    --hidden-size $NHIDDEN \
+    --ffn-hidden-size $FFN_HIDDEN_SIZE \
+    --num-attention-heads $NHEADS \
+    --seq-length $SEQ_LEN \
+    --max-position-embeddings $SEQ_LEN \
+    --micro-batch-size $MICRO_BATCH_SIZE \
+    --rampup-batch-size 16 16 5_000_000 \
+    --global-batch-size $GLOBAL_BATCH_SIZE \
+    --train-samples 300_000_000 \
+    --vocab-file $VOCAB_FILE \
+    --merge-file $MERGE_FILE \
+    --loss-scale 12 \
+    --clip-grad 1.0 \
+    --fp16 \
+    --checkpoint-activations \
+    --seed 42
+    $OPTIMIZER_ARGS \
+    $EXIT_OPTS \
+    "
+
+OUTPUT_ARGS=" \
+    --log-interval 10 \
+    --save-interval $SAVE_INTERVAL \
+    --eval-interval 1000 \
+    --eval-iters 5 \
+    --codecarbon-dir $CODECARBON_PATH \
+    --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.launch \
+    --nproc_per_node $GPUS_PER_NODE \
+    --nnodes $NNODES \
+    --master_addr $MASTER_ADDR \
+    --master_port $MASTER_PORT \
+    "
+
+#    /usr/bin/env PYTHONPATH="." `pwd`/pretrain_gpt.py \
+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 \
+    "
+
+echo $CMD
+
+# to debug - add echo (it exits and prints what it would have launched)
+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/tr1-13B-base/tr1-13B-slurm-status.slurm

@@ -0,0 +1,23 @@
+#!/bin/bash
+#SBATCH --job-name=tr1-13B-slurm-status  # job name
+#SBATCH --ntasks=1                   # number of MP tasks
+#SBATCH --nodes=1                    # number of nodes
+#SBATCH --cpus-per-task=1            # number of cores per task
+#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
+
+echo "START TIME: $(date)"
+
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr1-13B
+LOGS_PATH=$DATA_OUTPUT_PATH/logs
+MAIN_LOG_FILE=$LOGS_PATH/main_log.txt
+BIG_SCIENCE_REPO_PATH=$six_ALL_CCFRWORK/code/tr1-13B/bigscience
+# XXX: fix me on the next schedule when the name is fixed to remove .slurm
+WATCH_SLURM_NAME=tr1-13B-round3
+
+$BIG_SCIENCE_REPO_PATH/tools/slurm-status.py --job-name $WATCH_SLURM_NAME 2>&1 | tee -a $MAIN_LOG_FILE
+
+echo "END TIME: $(date)"

train/tr10-13B-ml/README.md

@@ -0,0 +1,111 @@
+# tr10 13B ML
+
+
+## setup/tune up
+
+
+To interactively tune up the setup:
+
+```
+salloc --constraint=v100-32g --account=six@v100 --nodes=4 --ntasks=4 --cpus-per-task=40 --gres=gpu:4 --hint=nomultithread --time=120 bash --rcfile $six_ALL_CCFRWORK/code/tr10-13B/bigscience/train/tr10-13B-ml/start-tr10-13B
+```
+
+
+Conda setup:
+
+```
+export CONDA_ENVS_PATH=$six_ALL_CCFRWORK/conda
+
+conda create -y -n tr10-13B python=3.8
+conda activate tr10-13B
+
+pip3 install torch==1.10.0+cu113 torchvision==0.11.1+cu113 torchaudio==0.10.0+cu113 -f https://download.pytorch.org/whl/cu113/torch_stable.html
+
+mkdir $six_ALL_CCFRWORK/code/tr10-13B
+cd $six_ALL_CCFRWORK/code/tr10-13B
+
+cd $six_ALL_CCFRWORK/code/tr10-13B/apex
+./build.sh
+
+pip install deepspeed
+
+cd $six_ALL_CCFRWORK/code/tr10-13B/DeepSpeed
+./build.sh
+
+pip install transformers
+
+cd $six_ALL_CCFRWORK/code/tr10-13B/transformers
+pip install -e .
+
+cd $six_ALL_CCFRWORK/code/tr10-13B/megatron-lm
+pip install -r requirements.txt
+```
+
+Env setup script to be `source start-tr10-13B` [start-tr10-13B](./start-tr10-13B)
+
+
+
+configs:
+
+works:
+```
+NNODES=4
+TP_SIZE=4
+PP_SIZE=4
+```
+
+
+tokenizer
+
+It's at https://huggingface.co/teven/test_150k_vocab_tokenizer/tree/main !
+
+So instead of running with :
+```
+--vocab-file $VOCAB_FILE \
+--merge-file $MERGE_FILE \
+```
+
+You should run with:
+```
+--tokenizer-type PretrainedFromHF \
+--tokenizer-name-or-path teven/test_150k_vocab_tokenizer \
+```
+
+Preprocessed a c4 10k samples, you can use it with:
+```
+DATA_PATH=$six_ALL_CCFRSCRATCH/datasets-custom/150k_vocab_size_test/c4_10k_samples_150k_vocab_size
+```
+
+## Config
+
+
+Julien Launay:
+
+(1) the main difference will be multilinguality, and the larger vocabulary.
+(2) For PrefixLM, we are not sure yet, as for now prefix is underperforming the vanilla model + it has some quirks. Thomas is working on a potential fix. We will keep you updated, but I think you can start working without prefix.
+(3) Embeddings. ALiBi is still underperforming all others. Maybe we could consider going with rotary? @Iz Beltagy what's your opinion on this? Rotary probably won't change significantly your benchmark, but will degrade performance by a few percents across the board.
+we don’t have a conclusive answer yet but both shouldn’t affect model size. If any, they will make the model a tiny bit smaller
+(4) Activation. We need to evaluate the GeGLU run. GeGLU would bring a significant change to the size of the MLPs, which would be significant for your benchmark.
+it shouldn’t change the overall model size but will change the size of some of the FF layers so might change how TP works
+
+### `--init-method-std`
+
+`--init-method-std 0.00884`
+
+We derived this from: `NHIDDEN=5120`
+
+`0.00884 = sqrt(2/(5120*5))` (from the ScaleNorm paper https://arxiv.org/abs/1910.05895)
+
+### `NHEADS`
+
+NHEADS=40, why...
+
+### `--embed-layernorm`
+
+We want this because it solved the problems with the 104B training instabilities.
+
+If we choose to train with it, we will need to add the additional code to for the HF GPT2 converted model.
+
+### `--partition-activations`
+
+can be used to shard activations across gpus to save more gpu memory

train/tr10-13B-ml/start-tr10-13B

@@ -0,0 +1,58 @@
+# This is a python production script for JZ / tr10-13B training
+#
+# Activate with:
+#
+# source ./start-tr10-13B
+#
+#
+
+# # 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.9.0
+module load nvtop 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 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 tr10-13B

train/tr10-13B-ml/tr10-13B.slurm

@@ -0,0 +1,182 @@
+#!/bin/bash
+#SBATCH --job-name=tr10-13B
+#SBATCH --constraint=v100-32g
+#SBATCH --nodes=4
+#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 --account=six@v100
+
+set -x -e
+
+source $six_ALL_CCFRWORK/code/tr10-13B/bigscience/train/tr10-13B-ml/start-tr10-13B
+
+echo "START TIME: $(date)"
+
+export HF_DATASETS_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr10-13B
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints
+REPO_PATH=$DATA_OUTPUT_PATH/tr10-13B-logs
+TENSORBOARD_PATH=$REPO_PATH/tensorboard
+LOGS_PATH=$REPO_PATH/logs
+mkdir -p $LOGS_PATH
+
+MEGATRON_DEEPSPEED_REPO=$six_ALL_CCFRWORK/code/tr10-13B/Megatron-DeepSpeed
+
+TOKENIZER_NAME=teven/test_150k_vocab_tokenizer
+DATA_PATH=$six_ALL_CCFRSCRATCH/datasets-custom/150k_vocab_size_test/c4_10k_samples_150k_vocab_size
+
+cd $MEGATRON_DEEPSPEED_REPO
+
+MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)
+MASTER_PORT=6000
+
+GPUS_PER_NODE=4
+NNODES=4   # switch to 128
+TP_SIZE=2    # always fixed to the size of a single node
+PP_SIZE=4   # NLAYERS must be a multiple of PP_SIZE here
+
+MICRO_BATCH_SIZE=1
+GLOBAL_BATCH_SIZE=2048
+
+NLAYERS=40
+NHIDDEN=5120
+NHEADS=32
+SEQ_LEN=2048
+VOCAB_SIZE=150000
+
+SAVE_INTERVAL=300
+
+OPTIMIZER_ARGS=" \
+    --optimizer adam \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.95 \
+    --adam-eps 1e-8 \
+    --lr 6e-5 \
+    --min-lr 6e-6 \
+    --lr-decay-style cosine \
+    --lr-decay-samples 126_953_125 \
+    --lr-warmup-samples 216_320 \
+    --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 \
+    --seq-length $SEQ_LEN \
+    --max-position-embeddings $SEQ_LEN \
+    --micro-batch-size $MICRO_BATCH_SIZE \
+    --rampup-batch-size 16 16 6_000_000 \
+    --global-batch-size $GLOBAL_BATCH_SIZE \
+    --train-samples 300_000_000 \
+    --tokenizer-type PretrainedFromHF \
+    --tokenizer-name-or-path $TOKENIZER_NAME \
+    --loss-scale 12 \
+    --init-method-std 0.00884 \
+    --fp16 \
+    --checkpoint-activations \
+    --seed 43 \
+    $OPTIMIZER_ARGS \
+    $EXIT_OPTS \
+    "
+
+OUTPUT_ARGS=" \
+    --log-interval 1 \
+    --save-interval $SAVE_INTERVAL \
+    --eval-interval 1000 \
+    --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 \
+    --log-level info \
+    --log-level-replica error \
+    "
+
+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 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 \
+    "
+
+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 900,100,0 \
+    --distributed-backend nccl \
+     $DEEPSPEED_ARGS \
+    "
+
+export OMP_NUM_THREADS=1 # shut up the launcher warnings
+
+echo $CMD
+
+# to debug - add echo (it exits and prints what it would have launched)
+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/tr12-1B3-oscar/tr12a-1B3-oscar-en-filtered.slurm

@@ -0,0 +1,191 @@
+#!/bin/bash
+#SBATCH --job-name=1B3-oscar-en-filtered.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-%a-%j.out        # output file name
+#SBATCH --error=%x-%a-%j.out         # error file name (same to watch just one file)
+#SBATCH --account=six@v100
+#SBATCH --mail-type=ALL
+#SBATCH [email protected]
+
+set -x -e
+
+
+ROUND=2
+TESTING=0
+
+EXPERIMENT_NAME=tr12a-1B3-oscar-en-filtered
+OUTPUT_PATH=$six_ALL_CCFRSCRATCH/synched_exps/$EXPERIMENT_NAME/
+CHECKPOINT_PATH=$OUTPUT_PATH/checkpoints
+REPO_PATH=$OUTPUT_PATH/$EXPERIMENT_NAME-logs
+TENSORBOARD_PATH=$REPO_PATH/tensorboard
+CODECARBON_PATH=$REPO_PATH/codecarbon
+LOGS_PATH=$REPO_PATH/logs
+
+MEGATRON_DEEPSPEED_REPO=$ALL_CCFRWORK/code/Megatron-DeepSpeed
+
+VOCAB_FILE=$MEGATRON_DEEPSPEED_REPO/data/gpt2-vocab.json
+MERGE_FILE=$MEGATRON_DEEPSPEED_REPO/data/gpt2-merges.txt
+DATA_PATH=/gpfsscratch/rech/six/urd43gx/oscar_en_v2_filtered/preprocessed_data_megatron/oscar_filtered_en_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
+
+# so processes know who to talk to
+MASTER_ADDR=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1`
+MASTER_PORT=6000
+
+# adjust depending on the number of the nodes
+
+# XXX: edit me
+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=146_484_375
+
+NLAYERS=24
+NHIDDEN=2048
+NHEADS=16
+FFN_HIDDEN_SIZE=8192
+SEQ_LEN=2048
+
+if   [[ ${ROUND} == 1 ]]; then  EXIT_INTERVAL=100    SAVE_INTERVAL=10
+elif [[ ${ROUND} == 2 ]]; then  SAVE_INTERVAL=1500
+else echo "invalid ROUND: $ROUND"
+fi
+
+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-decay-samples 146_484_375 \
+    --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 \
+    "
+
+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/tr12-1B3-oscar/tr12b-1B3-oscar-en-filtered-dedup.slurm

@@ -0,0 +1,191 @@
+#!/bin/bash
+#SBATCH --job-name=1B3-oscar-en-filtered-dedup.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-%a-%j.out        # output file name
+#SBATCH --error=%x-%a-%j.out         # error file name (same to watch just one file)
+#SBATCH --account=six@v100
+#SBATCH --mail-type=ALL
+#SBATCH [email protected]
+
+set -x -e
+
+
+ROUND=2
+TESTING=0
+
+EXPERIMENT_NAME=tr12b-1B3-oscar-en-filtered-dedup
+OUTPUT_PATH=$six_ALL_CCFRSCRATCH/synched_exps/$EXPERIMENT_NAME/
+CHECKPOINT_PATH=$OUTPUT_PATH/checkpoints
+REPO_PATH=$OUTPUT_PATH/$EXPERIMENT_NAME-logs
+TENSORBOARD_PATH=$REPO_PATH/tensorboard
+CODECARBON_PATH=$REPO_PATH/codecarbon
+LOGS_PATH=$REPO_PATH/logs
+
+MEGATRON_DEEPSPEED_REPO=$ALL_CCFRWORK/code/Megatron-DeepSpeed
+
+VOCAB_FILE=$MEGATRON_DEEPSPEED_REPO/data/gpt2-vocab.json
+MERGE_FILE=$MEGATRON_DEEPSPEED_REPO/data/gpt2-merges.txt
+DATA_PATH=/gpfsscratch/rech/six/urd43gx/oscar_en_v2_filtered/preprocessed_data_megatron_filtered_dedup_en/oscar_filtered_dedup_en_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
+
+# so processes know who to talk to
+MASTER_ADDR=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1`
+MASTER_PORT=6000
+
+# adjust depending on the number of the nodes
+
+# XXX: edit me
+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=146_484_375
+
+NLAYERS=24
+NHIDDEN=2048
+NHEADS=16
+FFN_HIDDEN_SIZE=8192
+SEQ_LEN=2048
+
+if   [[ ${ROUND} == 1 ]]; then  EXIT_INTERVAL=100    SAVE_INTERVAL=10
+elif [[ ${ROUND} == 2 ]]; then  SAVE_INTERVAL=1500
+else echo "invalid ROUND: $ROUND"
+fi
+
+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-decay-samples 146_484_375 \
+    --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 \
+    "
+
+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/tr12-1B3-oscar/tr12c-1B3-oscar-en-overfiltered.slurm

@@ -0,0 +1,191 @@
+#!/bin/bash
+#SBATCH --job-name=1B3-oscar-en-overfiltered.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-%a-%j.out        # output file name
+#SBATCH --error=%x-%a-%j.out         # error file name (same to watch just one file)
+#SBATCH --account=six@v100
+#SBATCH --mail-type=ALL
+#SBATCH [email protected]
+
+set -x -e
+
+
+ROUND=2
+TESTING=0
+
+EXPERIMENT_NAME=tr12c-1B3-oscar-en-overfiltered
+OUTPUT_PATH=$six_ALL_CCFRSCRATCH/synched_exps/$EXPERIMENT_NAME/
+CHECKPOINT_PATH=$OUTPUT_PATH/checkpoints
+REPO_PATH=$OUTPUT_PATH/$EXPERIMENT_NAME-logs
+TENSORBOARD_PATH=$REPO_PATH/tensorboard
+CODECARBON_PATH=$REPO_PATH/codecarbon
+LOGS_PATH=$REPO_PATH/logs
+
+MEGATRON_DEEPSPEED_REPO=$ALL_CCFRWORK/code/Megatron-DeepSpeed
+
+VOCAB_FILE=$MEGATRON_DEEPSPEED_REPO/data/gpt2-vocab.json
+MERGE_FILE=$MEGATRON_DEEPSPEED_REPO/data/gpt2-merges.txt
+DATA_PATH=/gpfsscratch/rech/six/urd43gx/oscar_en_v2_overfiltered/preprocessed_data_megatron/oscar_overfiltered_en_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
+
+# so processes know who to talk to
+MASTER_ADDR=`scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1`
+MASTER_PORT=6000
+
+# adjust depending on the number of the nodes
+
+# XXX: edit me
+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=146_484_375
+
+NLAYERS=24
+NHIDDEN=2048
+NHEADS=16
+FFN_HIDDEN_SIZE=8192
+SEQ_LEN=2048
+
+if   [[ ${ROUND} == 1 ]]; then  EXIT_INTERVAL=100    SAVE_INTERVAL=10
+elif [[ ${ROUND} == 2 ]]; then  SAVE_INTERVAL=1500
+else echo "invalid ROUND: $ROUND"
+fi
+
+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-decay-samples 146_484_375 \
+    --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 \
+    "
+
+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/tr13-mtf/smaller_models/tr13-6b3-mtf-xp3mt.slurm

@@ -0,0 +1,211 @@
+#!/bin/bash
+#SBATCH --job-name=xp3mt
+#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 8: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=xp3mt
+
+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/xp3mt_train.txt
+VALID_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3mt_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
+# 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/tr13b-1b3-ml-xp3capmixnewcodelonglossseq-a100.slurm

@@ -0,0 +1,211 @@
+#!/bin/bash
+#SBATCH --job-name=1b3xp3capmixnewcodelong
+#SBATCH --partition=gpu_p5
+#SBATCH --constraint=a100
+#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 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/tr13b-1B3-ml-t0
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints/$variant
+REPO_PATH=$DATA_OUTPUT_PATH/tr13b-1B3-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-tr13b-1B3-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.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=2
+
+# 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=2048
+
+NLAYERS=24
+NHIDDEN=2048
+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 2 \
+    --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/tr13b-1b3-ml-xp3capmixnewcodelonglossseq.slurm

@@ -0,0 +1,211 @@
+#!/bin/bash
+#SBATCH --job-name=1b3xp3capmixnewcodelong
+#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 -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/tr13b-1B3-ml-t0
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints/$variant
+REPO_PATH=$DATA_OUTPUT_PATH/tr13b-1B3-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-tr13b-1B3-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=2
+
+# 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=2048
+
+NLAYERS=24
+NHIDDEN=2048
+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/tr13c-2b5-mtf-xp3capmixnewcodelonglossseq-a100.slurm

@@ -0,0 +1,210 @@
+#!/bin/bash
+#SBATCH --job-name=2b5xp3capmixnewcodelong
+#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/tr13c-2B5-ml-t0
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints/$variant
+REPO_PATH=$DATA_OUTPUT_PATH/tr13c-2B5-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-tr13c-2B5-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.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=2048
+
+NLAYERS=30
+NHIDDEN=2560
+NHEADS=32
+SEQ_LEN=2048
+# 250
+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 \
+# --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 \
+    --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 2 \
+    --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/tr13c-2b5-mtf-xp3capmixnewcodelonglossseq.slurm

@@ -0,0 +1,211 @@
+#!/bin/bash
+#SBATCH --job-name=2b5xp3capmixnewcodelong
+#SBATCH --qos=qos_gpu-t3
+#SBATCH --nodes=32
+#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/tr13c-2B5-ml-t0
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints/$variant
+REPO_PATH=$DATA_OUTPUT_PATH/tr13c-2B5-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-tr13c-2B5-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=2048
+
+NLAYERS=30
+NHIDDEN=2560
+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 \
+# --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 2 \
+    --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-val.slurm

@@ -0,0 +1,211 @@
+#!/bin/bash
+#SBATCH --job-name=val350mxp3capmixnewcodelong
+#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 \
+OPTIMIZER_ARGS=" \
+    --optimizer adam \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.95 \
+    --adam-eps 1e-8 \
+    --lr 5e-4 \
+    --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 125 \
+    --eval-iters 10 \
+    --eval-only True \
+    --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-bos.slurm

@@ -0,0 +1,209 @@
+#!/bin/bash
+#SBATCH --job-name=bostr13f-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=bos
+
+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/p31bos_train.txt
+VALID_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/p31bos_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-xp3.slurm

@@ -0,0 +1,210 @@
+#!/bin/bash
+#SBATCH --job-name=xp3tr13f-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=xp3
+
+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/xp3_train.txt
+VALID_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3_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 \
+    --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-xp3mixed.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=xp3mixed
+
+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/xp3mixed_train.txt
+VALID_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3mixed_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.slurm

@@ -0,0 +1,209 @@
+#!/bin/bash
+#SBATCH --job-name=tr13f-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=logs/%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=main
+
+DATA_OUTPUT_PATH=$SCRATCH/checkpoints/tr13f-6B3-ml-t0
+CHECKPOINT_PATH=/gpfsscratch/rech/six/uty16tp/checkpoints/tr13f-6B3-ml-t0/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=$WORK/code/big_science/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=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 1000 \
+    --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_non_causal_decoder.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-p31lossseq.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/megdslossseq/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=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-xp3cap.slurm

@@ -0,0 +1,210 @@
+#!/bin/bash
+#SBATCH --job-name=xp3captr13f-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=xp3cap
+
+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/xp3cap_train.txt
+VALID_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3cap_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-xp3capmixfixlossseq.slurm

@@ -0,0 +1,211 @@
+#!/bin/bash
+#SBATCH --job-name=xp3capmixfixlossseq
+#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=xp3capmixfixlossseq
+
+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/xp3capmixfix_train.txt
+VALID_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3capmixfix_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-xp3capmixlossseq.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=xp3capmixlossseq
+
+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/megdslossseq/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-xp3capmixlossseqbos.slurm

@@ -0,0 +1,211 @@
+#!/bin/bash
+#SBATCH --job-name=xp3capmixlossseqbos
+#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=xp3capmixlossseqbos
+
+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/xp3capmixv3bos_train.txt
+VALID_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3capmixv3bos_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.slurm

@@ -0,0 +1,211 @@
+#!/bin/bash
+#SBATCH --job-name=xp3capmixnewcodelong
+#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=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.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/tr13f-6b3-mtf-xp3capmixnostriplossseq.slurm

@@ -0,0 +1,211 @@
+#!/bin/bash
+#SBATCH --job-name=xp3capmixnostriplossseq
+#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=xp3capmixnostriplossseq
+
+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/xp3capmixnostrip_train.txt
+VALID_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3capmixnostrip_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-xp3capmixv2lossseqbitfit.slurm

@@ -0,0 +1,211 @@
+#!/bin/bash
+#SBATCH --job-name=xp3capmixv2lossseqbitfit
+#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=xp3capmixv2lossseqbitfit
+
+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/megdslossseqbitfit/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/xp3capmixv2_train.txt
+VALID_DATA_PATH=$six_ALL_CCFRWORK/code/tr13f-6B3-ml-t0/Megatron-DeepSpeed/data/xp3capmixv2_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 4e-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 \
+    --bitfit \
+    --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-xp3zzlossseq.slurm

@@ -0,0 +1,211 @@
+#!/bin/bash
+#SBATCH --job-name=xp3zzlossseq
+#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=xp3zzlossseq
+
+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/xp3zzlossseq_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 250 \
+    --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/tr13-176B-mtf-p31lossseq-val.slurm

@@ -0,0 +1,225 @@
+#!/bin/bash
+#SBATCH --job-name=val-tr13-176B-ml-p31lossseq
+#SBATCH --partition=gpu_p5
+#SBATCH --constraint=a100
+#SBATCH --reservation=hug
+#SBATCH --qos=qos_gpu-gc             # up to 100h
+#SBATCH --nodes=36
+#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=p31lossseq
+
+DATA_OUTPUT_PATH=$six_ALL_CCFRSCRATCH/checkpoints/tr13-176B-ml-t0
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints/$variant
+REPO_PATH=$DATA_OUTPUT_PATH/tr13-176B-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-tr13-176B-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_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_JOB_ID 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
+
+# TP=1/PP=72/MBS=1/Nodes=36
+PP_SIZE=72
+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=2048
+
+NHIDDEN=14336
+NLAYERS=70
+NHEADS=112
+SEQ_LEN=2048
+
+# After CKPT is saved; stop training; change to desired SAVE_INTERNAL & remove no-load-optim & remove universal ckpt
+SAVE_INTERVAL=5
+
+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 \
+    --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 \
+    --sync-tp-duplicated-parameters \
+    --bf16 \
+    --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 10 \
+    --eval-only True \
+    --tensorboard-dir $TENSORBOARD_PATH \
+    --tensorboard-queue-size 5 \
+    --log-timers-to-tensorboard \
+    --log-batch-size-to-tensorboard \
+    --log-validation-ppl-to-tensorboard \
+    "
+
+ZERO_STAGE=0 # important: bf16 must use z0! it implements its own zero stage 1 equivalent
+
+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
+  },
+  "bf16": {
+    "enabled": true
+  },
+  "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 \
+    "
+
+#    --universal-checkpoint \
+export CMD=" \
+    `pwd`/finetune_t0.py \
+    --universal-checkpoint \
+    --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
+
+# force crashing on nccl issues like hanging broadcast
+export NCCL_ASYNC_ERROR_HANDLING=1
+
+# srun error handling:
+# --wait=60: wait 60 sec after the first task terminates before terminating all remaining tasks
+# --kill-on-bad-exit=1: terminate a step if any task exits with a non-zero exit code
+SRUN_ARGS=" \
+    --wait=60 \
+    --kill-on-bad-exit=1 \
+    "
+
+clear; srun $SRUN_ARGS --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/tr14-mup/grid_search.sh

@@ -0,0 +1,16 @@
+for inpm in 10 1 0.1 0.01 0.001
+do
+    for outm in 10 1 0.1 0.01 0.001
+    do
+        for atnm in 10 1 0.1 0.01 0.001
+        do
+            for lr in 0.1 0.03 0.01 0.003 0.001
+            do
+                for init in 1 0.3 0.1 0.03 0.01
+                do
+                    sbatch --job-name=tr14-39M-lr$lr-init$init-inpm$inpm-outm$outm-atnm$atnm-mup tr14-39M-grid-search-mup.slurm $lr $init $inpm $outm $atnm
+                done
+            done
+        done
+    done
+done

train/tr14-mup/lr_sweep.sh

@@ -0,0 +1,7 @@
+for lr in 0.052 0.017 0.0052 0.0017; do
+    sbatch --job-name=tr14-39M-lr$lr-init0.1-inpm10-outm10-atnm10-mup tr14-39M-grid-search-mup.slurm $lr 0.1 10 10 10
+done
+
+for lr in 0.01 0.052 0.03 0.017 0.01 0.0052 0.003 0.0017 0.001; do
+    sbatch --job-name=tr14-2B7-lr$lr-init0.1-inpm10-outm10-atnm10-mup tr14-2B7-grid-search-mup.slurm $lr 0.1 10 10 10
+done

train/tr14-mup/tr14-2B7-grid-search-mup.slurm

@@ -0,0 +1,206 @@
+#!/bin/bash
+#SBATCH --qos=qos_gpu-t3
+#SBATCH --nodes=2
+#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:8                 # number of gpus
+#SBATCH --time 04:00:00             # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x.out           # output file name
+#SBATCH --partition=gpu_p5
+#SBATCH --account=ajs@a100
+#SBATCH -C a100
+
+set -x -e
+
+#source $ajs_ALL_CCFRWORK/start-py38-pt110
+#source $ajs_ALL_CCFRWORK/start-py38-pt111
+source $six_ALL_CCFRWORK/code/tr11-176B-ml/bigscience/train/tr11-176B-ml/start-tr11-176B-ml
+
+echo "START TIME: $(date)"
+
+variant=main
+
+DATA_PATH=$ajs_ALL_CCFRSCRATCH/datasets/c4/gpt2tok_c4_text_document
+DATA_OUTPUT_PATH=$ajs_ALL_CCFRSCRATCH/checkpoints/tr14-2B7-mup-lr$1-init$2-inpm$3-outm$4-atnm$5-mup
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints/$variant
+REPO_PATH=$DATA_OUTPUT_PATH/tr14-2B7-mup-lr$1-init$2-inpm$3-outm$4-atnm$5-mup-logs
+TENSORBOARD_PATH=$REPO_PATH/tensorboard/$variant
+LOGS_PATH=$REPO_PATH/logs/$variant
+mkdir -p $LOGS_PATH
+
+MEGATRON_DEEPSPEED_REPO=$ajs_ALL_CCFRWORK/code/Megatron-DeepSpeed
+cd $MEGATRON_DEEPSPEED_REPO
+
+TOKENIZER_NAME_OR_PATH=t5-small
+
+# defining the right environment variables
+export TRANSFORMERS_CACHE=$ajs_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$ajs_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$ajs_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$ajs_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=6000
+
+GPUS_PER_NODE=8
+NNODES=$SLURM_NNODES
+
+PP_SIZE=1
+TP_SIZE=2
+
+MICRO_BATCH_SIZE=1
+GLOBAL_BATCH_SIZE=512
+
+NLAYERS=32
+NHIDDEN=2560
+NHEADS=32
+SEQ_LEN=2048
+
+SAVE_INTERVAL=250
+
+TRAIN_SAMPLES=25_000_000  # 51.2B tokens
+LR_DECAY_SAMPLES=25_000_000  # Decay in the same amount
+LR_WARMUP_SAMPLES=183_105  # 375M tokens
+
+
+MUP_ARGS=" \
+    --lr $1 \
+    --min-lr `bc <<< "scale=3; $1/10"` \
+    --init-method-std $2 \
+    --mup \
+    --mup-input-mult $3 \
+    --mup-output-mult $4 \
+    --mup-attn-mult $5 \
+"
+
+
+OPTIMIZER_ARGS=" \
+    --optimizer adam \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.95 \
+    --adam-eps 1e-8 \
+    --lr-decay-style cosine \
+    --lr-decay-samples $LR_DECAY_SAMPLES \
+    --lr-warmup-samples $LR_WARMUP_SAMPLES \
+    --clip-grad 1.0 \
+    --weight-decay 1e-1 \
+    "
+# for 20h 1190, for 100h 5990
+EXIT_OPTS=" \
+    --exit-duration-in-mins 1190 \
+    "
+
+GPT_ARGS=" \
+    --pp-partition-method 'type:transformer' \
+    --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 \
+    --rampup-batch-size 192 32 9_765_625 \
+    --global-batch-size $GLOBAL_BATCH_SIZE \
+    --train-samples $TRAIN_SAMPLES \
+    --tokenizer-type PretrainedFromHF \
+    --tokenizer-name-or-path $TOKENIZER_NAME_OR_PATH \
+    --embed-layernorm \
+    --fp16 \
+    --seed 42 \
+    --position-embedding-type alibi \
+    --checkpoint-activations \
+    --abort-on-unmet-fused-kernel-constraints \
+    --pad-vocab-size-to 51200 \
+    $OPTIMIZER_ARGS \
+    $EXIT_OPTS \
+    "
+
+# TODO: decide on efficient eval-interval + eval-iters
+
+OUTPUT_ARGS=" \
+    --log-interval 1 \
+    --save-interval $SAVE_INTERVAL \
+    --eval-interval 1000 \
+    --eval-iters 1 \
+    --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`/pretrain_gpt.py \
+    --tensor-model-parallel-size $TP_SIZE \
+    --pipeline-model-parallel-size $PP_SIZE \
+    $GPT_ARGS \
+    $OUTPUT_ARGS \
+    $MUP_ARGS \
+    --save $CHECKPOINT_PATH \
+    --load $CHECKPOINT_PATH \
+    --data-path $DATA_PATH \
+    --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/tr14-mup/tr14-2B7-mup-cluster.slurm

@@ -0,0 +1,237 @@
+#!/bin/bash
+#SBATCH --job-name=tr14-2B7-mup
+#SBATCH --partition=production-cluster
+#SBATCH --nodes=8
+#SBATCH --cpus-per-task=12
+#SBATCH --ntasks-per-node=1
+#SBATCH --gres=gpu:a100:8
+#SBATCH --hint=nomultithread
+#SBATCH --time 100:00:00
+#SBATCH --output=/fsx/teven/mup/tr14-2B7-%j.out
+#SBATCH --exclude=ip-26-0-159-215,ip-26-0-153-238
+
+echo "START TIME: $(date)"
+
+mkdir -p $LOGS_PATH
+
+# >>> conda initialize >>>
+# !! Contents within this block are managed by 'conda init' !!
+__conda_setup="$('/admin/home/teven/miniconda3/bin/conda' 'shell.bash' 'hook' 2> /dev/null)"
+if [ $? -eq 0 ]; then
+    eval "$__conda_setup"
+else
+    if [ -f "/admin/home/teven/miniconda3/etc/profile.d/conda.sh" ]; then
+        . "/admin/home/teven/miniconda3/etc/profile.d/conda.sh"
+    else
+        export PATH="/admin/home/teven/miniconda3/bin:$PATH"
+    fi
+fi
+unset __conda_setup
+# <<< conda initialize <<<
+
+# Proper env variables
+conda activate tvn_dev
+export PATH=/usr/local/cuda-11.4/bin:$PATH
+export NCCL_PROTO=simple
+export PATH=/opt/amazon/efa/bin:$PATH
+
+export FI_EFA_FORK_SAFE=1
+export FI_LOG_LEVEL=1
+export FI_EFA_USE_DEVICE_RDMA=1 # use for p4dn
+
+#export NCCL_ALGO=ring
+#export NCCL_DEBUG=info
+#export NCCL_DEBUG_SUBSYS=INIT,ENV,GRAPH,COLL
+
+export PYTHONFAULTHANDLER=1
+
+export CUDA_LAUNCH_BLOCKING=0
+export OMPI_MCA_mtl_base_verbose=1
+export FI_EFA_ENABLE_SHM_TRANSFER=0
+export FI_PROVIDER=efa
+export FI_EFA_TX_MIN_CREDITS=64
+export NCCL_TREE_THRESHOLD=0
+#export TORCH_CPP_LOG_LEVEL=INFO
+#export TORCH_DISTRIBUTED_DEBUG=INFO
+
+export NCCL_ASYNC_ERROR_HANDLING=1
+#export NCCL_P2P_DISABLE=1
+#export NCCL_IBEXT_DISABLE=1
+#export NCCL_SOCKET_IFNAME="eth0,en,eth,em,bond"
+
+# 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
+export MASTER_ADDR=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1)
+export MASTER_PORT=12802
+
+
+MEGATRON_DEEPSPEED_REPO=/fsx/teven/Megatron-DeepSpeed
+cd $MEGATRON_DEEPSPEED_REPO
+
+TOKENIZER_NAME_OR_PATH=t5-small
+
+variant=main
+
+DATA_PATH=/fsx/data/gpt2tok_c4_text_document
+DATA_OUTPUT_PATH=/fsx/mup_exps/checkpoints/tr14-2B7-lr$1-init0.1-inpm10-outm10-atnm10-mup
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints/$variant
+REPO_PATH=$DATA_OUTPUT_PATH/tr14-2B7-test-lr$1-init0.1-inpm10-outm10-atnm10-mup
+TENSORBOARD_PATH=$REPO_PATH/tensorboard/$variant
+LOGS_PATH=$REPO_PATH/logs/$variant
+
+GPUS_PER_NODE=8
+NNODES=$SLURM_NNODES
+
+PP_SIZE=1
+TP_SIZE=2
+
+MICRO_BATCH_SIZE=16
+GLOBAL_BATCH_SIZE=512
+
+NLAYERS=32
+NHIDDEN=2560
+NHEADS=32
+SEQ_LEN=2048
+
+SAVE_INTERVAL=250
+
+TRAIN_SAMPLES=1_953_125  # 50B tokens
+LR_DECAY_SAMPLES=1_953_125  # Decay in the same amount
+LR_WARMUP_SAMPLES=183_105  # 375M tokens
+
+
+MUP_ARGS=" \
+    --lr $1 \
+    --min-lr `bc <<< "scale=3; $1/10"` \
+    --init-method-std 0.1 \
+    --mup \
+    --mup-input-mult 10 \
+    --mup-output-mult 10 \
+    --mup-attn-mult 10 \
+"
+
+
+OPTIMIZER_ARGS=" \
+    --optimizer adam \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.95 \
+    --adam-eps 1e-8 \
+    --lr-decay-style cosine \
+    --lr-decay-samples $LR_DECAY_SAMPLES \
+    --lr-warmup-samples $LR_WARMUP_SAMPLES \
+    --clip-grad 1.0 \
+    --weight-decay 1e-1 \
+    "
+# for 20h 1190, for 100h 5990
+EXIT_OPTS=" \
+    --exit-duration-in-mins 1190 \
+    "
+
+GPT_ARGS=" \
+    --pp-partition-method 'type:transformer' \
+    --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 \
+    --embed-layernorm \
+    --fp16 \
+    --seed 42 \
+    --position-embedding-type alibi \
+    --checkpoint-activations \
+    --abort-on-unmet-fused-kernel-constraints \
+    --pad-vocab-size-to 51200 \
+    $OPTIMIZER_ARGS \
+    $EXIT_OPTS \
+    "
+
+# TODO: decide on efficient eval-interval + eval-iters
+
+OUTPUT_ARGS=" \
+    --log-interval 1 \
+    --save-interval $SAVE_INTERVAL \
+    --eval-interval 1000 \
+    --eval-iters 1 \
+    --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`/pretrain_gpt.py \
+    --tensor-model-parallel-size $TP_SIZE \
+    --pipeline-model-parallel-size $PP_SIZE \
+    $GPT_ARGS \
+    $OUTPUT_ARGS \
+    $MUP_ARGS \
+    --save $CHECKPOINT_PATH \
+    --load $CHECKPOINT_PATH \
+    --data-path $DATA_PATH \
+    --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/tr14-mup/tr14-2B7-mup.slurm

@@ -0,0 +1,205 @@
+#!/bin/bash
+#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=16           # number of cores per tasks
+#SBATCH --hint=nomultithread         # we get physical cores not logical
+#SBATCH --gres=gpu:8                 # number of gpus
+#SBATCH --time 05:00:00             # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x.out           # output file name
+#SBATCH --partition=gpu_p5
+#SBATCH --account=ajs@a100
+#SBATCH -C a100
+
+set -x -e
+
+#source $ajs_ALL_CCFRWORK/start-py38-pt110
+#source $ajs_ALL_CCFRWORK/start-py38-pt111
+source $six_ALL_CCFRWORK/code/tr11-176B-ml/bigscience/train/tr11-176B-ml/start-tr11-176B-ml
+
+echo "START TIME: $(date)"
+
+variant=main
+
+DATA_PATH=$ajs_ALL_CCFRSCRATCH/datasets/c4/gpt2tok_c4_text_document
+DATA_OUTPUT_PATH=$ajs_ALL_CCFRSCRATCH/checkpoints/tr14-2B7-lr$1-init0.1-inpm10-outm10-atnm10-mup
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints/$variant
+REPO_PATH=$DATA_OUTPUT_PATH/tr14-2B7-test-lr$1-init0.1-inpm10-outm10-atnm10-mup
+TENSORBOARD_PATH=$REPO_PATH/tensorboard/$variant
+LOGS_PATH=$REPO_PATH/logs/$variant
+mkdir -p $LOGS_PATH
+
+MEGATRON_DEEPSPEED_REPO=$ajs_ALL_CCFRWORK/code/Megatron-DeepSpeed
+cd $MEGATRON_DEEPSPEED_REPO
+
+TOKENIZER_NAME_OR_PATH=t5-small
+
+# defining the right environment variables
+export TRANSFORMERS_CACHE=$ajs_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$ajs_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$ajs_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$ajs_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=6000
+
+GPUS_PER_NODE=8
+NNODES=$SLURM_NNODES
+
+PP_SIZE=1
+TP_SIZE=2
+
+MICRO_BATCH_SIZE=16
+GLOBAL_BATCH_SIZE=512
+
+NLAYERS=32
+NHIDDEN=2560
+NHEADS=32
+SEQ_LEN=2048
+
+SAVE_INTERVAL=250
+
+TRAIN_SAMPLES=1_953_125  # 50B tokens
+LR_DECAY_SAMPLES=1_953_125  # Decay in the same amount
+LR_WARMUP_SAMPLES=183_105  # 375M tokens
+
+
+MUP_ARGS=" \
+    --lr $1 \
+    --min-lr `bc <<< "scale=3; $1/10"` \
+    --init-method-std 0.1 \
+    --mup \
+    --mup-input-mult 10 \
+    --mup-output-mult 10 \
+    --mup-attn-mult 10 \
+"
+
+
+OPTIMIZER_ARGS=" \
+    --optimizer adam \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.95 \
+    --adam-eps 1e-8 \
+    --lr-decay-style cosine \
+    --lr-decay-samples $LR_DECAY_SAMPLES \
+    --lr-warmup-samples $LR_WARMUP_SAMPLES \
+    --clip-grad 1.0 \
+    --weight-decay 1e-1 \
+    "
+# for 20h 1190, for 100h 5990
+EXIT_OPTS=" \
+    --exit-duration-in-mins 1190 \
+    "
+
+GPT_ARGS=" \
+    --pp-partition-method 'type:transformer' \
+    --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 \
+    --embed-layernorm \
+    --fp16 \
+    --seed 42 \
+    --position-embedding-type alibi \
+    --checkpoint-activations \
+    --abort-on-unmet-fused-kernel-constraints \
+    --pad-vocab-size-to 51200 \
+    $OPTIMIZER_ARGS \
+    $EXIT_OPTS \
+    "
+
+# TODO: decide on efficient eval-interval + eval-iters
+
+OUTPUT_ARGS=" \
+    --log-interval 1 \
+    --save-interval $SAVE_INTERVAL \
+    --eval-interval 1000 \
+    --eval-iters 1 \
+    --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`/pretrain_gpt.py \
+    --tensor-model-parallel-size $TP_SIZE \
+    --pipeline-model-parallel-size $PP_SIZE \
+    $GPT_ARGS \
+    $OUTPUT_ARGS \
+    $MUP_ARGS \
+    --save $CHECKPOINT_PATH \
+    --load $CHECKPOINT_PATH \
+    --data-path $DATA_PATH \
+    --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/tr14-mup/tr14-39M-grid-search-mup.slurm

@@ -0,0 +1,204 @@
+#!/bin/bash
+#SBATCH --qos=qos_gpu-t3
+#SBATCH --nodes=1
+#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:8                 # number of gpus
+#SBATCH --time 04:00:00             # maximum execution time (HH:MM:SS)
+#SBATCH --output=%x.out           # output file name
+#SBATCH --partition=gpu_p5
+#SBATCH --account=ajs@a100
+#SBATCH -C a100
+
+set -x -e
+
+#source $ajs_ALL_CCFRWORK/start-py38-pt110
+#source $ajs_ALL_CCFRWORK/start-py38-pt111
+source $six_ALL_CCFRWORK/code/tr11-176B-ml/bigscience/train/tr11-176B-ml/start-tr11-176B-ml
+
+echo "START TIME: $(date)"
+
+variant=main
+
+DATA_PATH=$ajs_ALL_CCFRSCRATCH/datasets/c4/gpt2tok_c4_text_document
+DATA_OUTPUT_PATH=$ajs_ALL_CCFRSCRATCH/checkpoints/tr14-39M-lr$1-init$2-inpm$3-outm$4-atnm$5-mup
+CHECKPOINT_PATH=$DATA_OUTPUT_PATH/checkpoints/$variant
+REPO_PATH=$DATA_OUTPUT_PATH/tr14-39M-lr$1-init$2-inpm$3-outm$4-atnm$5-mup-logs
+TENSORBOARD_PATH=$REPO_PATH/tensorboard/$variant
+LOGS_PATH=$REPO_PATH/logs/$variant
+mkdir -p $LOGS_PATH
+
+MEGATRON_DEEPSPEED_REPO=$ajs_ALL_CCFRWORK/code/Megatron-DeepSpeed
+cd $MEGATRON_DEEPSPEED_REPO
+
+TOKENIZER_NAME_OR_PATH=gpt2
+
+# defining the right environment variables
+export TRANSFORMERS_CACHE=$ajs_ALL_CCFRWORK/models
+export HF_DATASETS_CACHE=$ajs_ALL_CCFRWORK/datasets
+export HF_MODULES_CACHE=$ajs_ALL_CCFRWORK/modules
+export HF_METRICS_CACHE=$ajs_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=6000
+
+GPUS_PER_NODE=8
+NNODES=$SLURM_NNODES
+
+PP_SIZE=1
+TP_SIZE=1
+
+MICRO_BATCH_SIZE=32
+GLOBAL_BATCH_SIZE=512
+
+NLAYERS=32
+NHIDDEN=256
+NHEADS=8
+SEQ_LEN=2048
+
+SAVE_INTERVAL=1000
+
+TRAIN_SAMPLES=1_953_125  # 40B tokens
+LR_DECAY_SAMPLES=1_953_125  # Decay in the same amount
+LR_WARMUP_SAMPLES=183_105  # 375M tokens
+
+
+MUP_ARGS=" \
+    --lr $1 \
+    --min-lr `bc <<< "scale=3; $1/10"` \
+    --init-method-std $2 \
+    --mup \
+    --mup-input-mult $3 \
+    --mup-output-mult $4 \
+    --mup-attn-mult $5 \
+"
+
+
+OPTIMIZER_ARGS=" \
+    --optimizer adam \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.95 \
+    --adam-eps 1e-8 \
+    --lr-decay-style cosine \
+    --lr-decay-samples $LR_DECAY_SAMPLES \
+    --lr-warmup-samples $LR_WARMUP_SAMPLES \
+    --clip-grad 1.0 \
+    --weight-decay 1e-1 \
+    "
+# for 20h 1190, for 100h 5990
+EXIT_OPTS=" \
+    --exit-duration-in-mins 1190 \
+    "
+
+GPT_ARGS=" \
+    --pp-partition-method 'type:transformer' \
+    --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 \
+    --embed-layernorm \
+    --fp16 \
+    --seed 42 \
+    --position-embedding-type alibi \
+    --checkpoint-activations \
+    --abort-on-unmet-fused-kernel-constraints \
+    --pad-vocab-size-to 51200 \
+    $OPTIMIZER_ARGS \
+    $EXIT_OPTS \
+    "
+
+# TODO: decide on efficient eval-interval + eval-iters
+
+OUTPUT_ARGS=" \
+    --log-interval 10 \
+    --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 \
+    "
+
+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`/pretrain_gpt.py \
+    --tensor-model-parallel-size $TP_SIZE \
+    --pipeline-model-parallel-size $PP_SIZE \
+    $GPT_ARGS \
+    $OUTPUT_ARGS \
+    $MUP_ARGS \
+    --save $CHECKPOINT_PATH \
+    --data-path $DATA_PATH \
+    --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)"