Add files using upload-large-folder tool

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/CODEOWNERS

@@ -0,0 +1 @@
+*       @jeffra @samyam @tjruwase @ShadenSmith @conglongli @awan-10 @cli99 @eltonzheng @minjiaz @RezaYazdaniAminabadi @duli2012 @mrwyattii @yaozhewei @arashb @xiaoxiawu-microsoft @guanhuawang

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/LICENSE

@@ -0,0 +1,265 @@
+The following applies to all files unless otherwise noted:
+# Copyright (c) 2023 Habana Labs, Ltd. an Intel Company
+# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#  * Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+#  * Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+#  * Neither the name of NVIDIA CORPORATION nor the names of its
+#    contributors may be used to endorse or promote products derived
+#    from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+--
+
+This repository also contains code from Hugging Face Inc., Google Research,
+Facebook (from their Fairseq project), and Philip Popien. Files from these
+organizations have notices at the top of each file. Below are licenses
+used in those files, as indicated.
+
+
+------------- LICENSE FOR huggingface and Google Research code  --------------
+
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+------------- LICENSE FOR Facebook Fairseq code --------------
+
+MIT License
+
+Copyright (c) Facebook, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/MANIFEST.in

@@ -0,0 +1,2 @@
+include megatron/data/Makefile
+include megatron/data/helpers.cpp

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/SECURITY.md

@@ -0,0 +1,41 @@
+<!-- BEGIN MICROSOFT SECURITY.MD V0.0.7 BLOCK -->
+
+## Security
+
+Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), and [our GitHub organizations](https://opensource.microsoft.com/).
+
+If you believe you have found a security vulnerability in any Microsoft-owned repository that meets [Microsoft's definition of a security vulnerability](https://aka.ms/opensource/security/definition), please report it to us as described below.
+
+## Reporting Security Issues
+
+**Please do not report security vulnerabilities through public GitHub issues.**
+
+Instead, please report them to the Microsoft Security Response Center (MSRC) at [https://msrc.microsoft.com/create-report](https://aka.ms/opensource/security/create-report).
+
+If you prefer to submit without logging in, send email to [[email protected]](mailto:[email protected]).  If possible, encrypt your message with our PGP key; please download it from the [Microsoft Security Response Center PGP Key page](https://aka.ms/opensource/security/pgpkey).
+
+You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Additional information can be found at [microsoft.com/msrc](https://aka.ms/opensource/security/msrc). 
+
+Please include the requested information listed below (as much as you can provide) to help us better understand the nature and scope of the possible issue:
+
+  * Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.)
+  * Full paths of source file(s) related to the manifestation of the issue
+  * The location of the affected source code (tag/branch/commit or direct URL)
+  * Any special configuration required to reproduce the issue
+  * Step-by-step instructions to reproduce the issue
+  * Proof-of-concept or exploit code (if possible)
+  * Impact of the issue, including how an attacker might exploit the issue
+
+This information will help us triage your report more quickly.
+
+If you are reporting for a bug bounty, more complete reports can contribute to a higher bounty award. Please visit our [Microsoft Bug Bounty Program](https://aka.ms/opensource/security/bounty) page for more details about our active programs.
+
+## Preferred Languages
+
+We prefer all communications to be in English.
+
+## Policy
+
+Microsoft follows the principle of [Coordinated Vulnerability Disclosure](https://aka.ms/opensource/security/cvd).
+
+<!-- END MICROSOFT SECURITY.MD BLOCK -->

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/dataset/README.md

@@ -0,0 +1,5 @@
+# Run the scripts below to setup dataset 
+
+bash download_books.sh
+
+bash download_vocab.sh

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/dataset/download_books.sh

@@ -0,0 +1,2 @@
+wget https://the-eye.eu/public/AI/pile_neox/data/BookCorpusDataset_text_document.bin
+wget https://the-eye.eu/public/AI/pile_neox/data/BookCorpusDataset_text_document.idx

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/dataset/download_ckpt.sh

@@ -0,0 +1,8 @@
+mkdir -p checkpoints/gpt2_345m
+
+cd checkpoints/gpt2_345m
+wget --content-disposition https://api.ngc.nvidia.com/v2/models/nvidia/megatron_lm_345m/versions/v0.0/zip -O megatron_lm_345m_v0.0.zip
+unzip megatron_lm_345m_v0.0.zip
+rm megatron_lm_345m_v0.0.zip
+cd ../..
+

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/dataset/download_vocab.sh

@@ -0,0 +1,2 @@
+wget https://s3.amazonaws.com/models.huggingface.co/bert/gpt2-vocab.json
+wget https://s3.amazonaws.com/models.huggingface.co/bert/gpt2-merges.txt

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/examples/README.md

@@ -0,0 +1,15 @@
+## Recipes and Scripts
+
+### Azure
+
+We strongly recommend to start with AzureML recipe in the ```azureml``` folder.
+
+If you have a custom infrastructure (e.g. HPC clusters) or Azure VM and VMSS based environments, please refer to the bash scripts in the ```azure``` folder.
+
+### MoE
+
+Please see the ```MoE``` folder for different training recipes and scripts for Mixture-of-expert based models. 
+
+### Curriculum Learning
+
+Curriculum learning recipes are in the ```curriculum_learning``` folder. Please refer to the detailed tutorials linked inside. 

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/examples/create_embeddings.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+
+# Compute embeddings for each entry of a given dataset (e.g. Wikipedia)
+
+RANK=0
+WORLD_SIZE=1
+
+# Wikipedia data can be downloaded from the following link:
+# https://github.com/facebookresearch/DPR/blob/master/data/download_data.py
+EVIDENCE_DATA_DIR=<Specify path of Wikipedia dataset>
+EMBEDDING_PATH=<Specify path to store embeddings>
+CHECKPOINT_PATH=<Specify path of pretrained ICT model>
+
+python tools/create_doc_index.py \
+    --num-layers 12 \
+    --hidden-size 768 \
+    --num-attention-heads 12 \
+    --tensor-model-parallel-size 1 \
+    --micro-batch-size 128 \
+    --checkpoint-activations \
+    --seq-length 512 \
+    --retriever-seq-length 256 \
+    --max-position-embeddings 512 \
+    --load ${CHECKPOINT_PATH} \
+    --evidence-data-path ${EVIDENCE_DATA_DIR} \
+    --embedding-path ${EMBEDDING_PATH} \
+    --indexer-log-interval 1000 \
+    --indexer-batch-size 128 \
+    --vocab-file bert-vocab.txt \
+    --num-workers 2 \
+    --fp16
+

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/examples/evaluate_ict_zeroshot_nq.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+
+# Evaluate natural question test data given Wikipedia embeddings and pretrained
+# ICT model
+
+# Datasets can be downloaded from the following link:
+# https://github.com/facebookresearch/DPR/blob/master/data/download_data.py
+
+EVIDENCE_DATA_DIR=<Specify path of Wikipedia dataset>
+EMBEDDING_PATH=<Specify path of the embeddings>
+CHECKPOINT_PATH=<Specify path of pretrained ICT model>
+
+QA_FILE=<Path of the natural question test dataset>
+
+python tasks/main.py \
+    --task ICT-ZEROSHOT-NQ \
+    --tokenizer-type BertWordPieceLowerCase \
+    --num-layers 12 \
+    --hidden-size 768 \
+    --num-attention-heads 12 \
+    --tensor-model-parallel-size 1 \
+    --micro-batch-size 128 \
+    --checkpoint-activations \
+    --seq-length 512 \
+    --max-position-embeddings 512 \
+    --load ${CHECKPOINT_PATH} \
+    --evidence-data-path ${EVIDENCE_DATA_DIR} \
+    --embedding-path ${EMBEDDING_PATH} \
+    --retriever-seq-length 256 \
+    --vocab-file  bert-vocab.txt\
+    --qa-data-test ${QA_FILE} \
+    --num-workers 2 \
+    --faiss-use-gpu \
+    --retriever-report-topk-accuracies 1 5 20 100 \
+    --fp16
+

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/examples/finetune_mnli_distributed.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+
+WORLD_SIZE=8
+
+DISTRIBUTED_ARGS="--nproc_per_node $WORLD_SIZE \
+                  --nnodes 1 \
+                  --node_rank 0 \
+                  --master_addr localhost \
+                  --master_port 6000"
+
+TRAIN_DATA="data/glue_data/MNLI/train.tsv"
+VALID_DATA="data/glue_data/MNLI/dev_matched.tsv \
+            data/glue_data/MNLI/dev_mismatched.tsv"
+PRETRAINED_CHECKPOINT=checkpoints/bert_345m
+VOCAB_FILE=bert-vocab.txt
+CHECKPOINT_PATH=checkpoints/bert_345m_mnli
+
+python -m torch.distributed.launch $DISTRIBUTED_ARGS ./tasks/main.py \
+               --task MNLI \
+               --seed 1234 \
+               --train-data $TRAIN_DATA \
+               --valid-data $VALID_DATA \
+               --tokenizer-type BertWordPieceLowerCase \
+               --vocab-file $VOCAB_FILE \
+               --epochs 5 \
+               --pretrained-checkpoint $PRETRAINED_CHECKPOINT \
+               --tensor-model-parallel-size 1 \
+               --num-layers 24 \
+               --hidden-size 1024 \
+               --num-attention-heads 16 \
+               --micro-batch-size 8 \
+               --checkpoint-activations \
+               --lr 5.0e-5 \
+               --lr-decay-style linear \
+               --lr-warmup-fraction 0.065 \
+               --seq-length 512 \
+               --max-position-embeddings 512 \
+               --save-interval 500000 \
+               --save $CHECKPOINT_PATH \
+               --log-interval 10 \
+               --eval-interval 100 \
+               --eval-iters 50 \
+               --weight-decay 1.0e-1 \
+               --fp16

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/examples/finetune_race_distributed.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+
+WORLD_SIZE=8
+
+DISTRIBUTED_ARGS="--nproc_per_node $WORLD_SIZE \
+                  --nnodes 1 \
+                  --node_rank 0 \
+                  --master_addr localhost \
+                  --master_port 6000"
+
+TRAIN_DATA="data/RACE/train/middle"
+VALID_DATA="data/RACE/dev/middle \
+            data/RACE/dev/high"
+VOCAB_FILE=bert-vocab.txt
+PRETRAINED_CHECKPOINT=checkpoints/bert_345m
+CHECKPOINT_PATH=checkpoints/bert_345m_race
+
+python -m torch.distributed.launch $DISTRIBUTED_ARGS ./tasks/main.py \
+               --task RACE \
+               --seed 1234 \
+               --train-data $TRAIN_DATA \
+               --valid-data $VALID_DATA \
+               --tokenizer-type BertWordPieceLowerCase \
+               --vocab-file $VOCAB_FILE \
+               --epochs 3 \
+               --pretrained-checkpoint $PRETRAINED_CHECKPOINT \
+               --tensor-model-parallel-size 1 \
+               --num-layers 24 \
+               --hidden-size 1024 \
+               --num-attention-heads 16 \
+               --micro-batch-size 4 \
+               --checkpoint-activations \
+               --lr 1.0e-5 \
+               --lr-decay-style linear \
+               --lr-warmup-fraction 0.06 \
+               --seq-length 512 \
+               --max-position-embeddings 512 \
+               --save-interval 100000 \
+               --save $CHECKPOINT_PATH \
+               --log-interval 10 \
+               --eval-interval 100 \
+               --eval-iters 50 \
+               --weight-decay 1.0e-1 \
+               --clip-grad 1.0 \
+               --hidden-dropout 0.1 \
+               --attention-dropout 0.1 \
+               --fp16

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/examples/pretrain_bert.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+
+RANK=0
+WORLD_SIZE=1
+DATA_PATH=<Specify path and file prefix>_text_sentence
+CHECKPOINT_PATH=<Specify path>
+
+python pretrain_bert.py \
+       --num-layers 24 \
+       --hidden-size 1024 \
+       --num-attention-heads 16 \
+       --micro-batch-size 4 \
+       --global-batch-size 8 \
+       --seq-length 512 \
+       --max-position-embeddings 512 \
+       --train-iters 2000000 \
+       --lr-decay-iters 990000 \
+       --save $CHECKPOINT_PATH \
+       --load $CHECKPOINT_PATH \
+       --data-path $DATA_PATH \
+       --vocab-file bert-vocab.txt \
+       --data-impl mmap \
+       --split 949,50,1 \
+       --lr 0.0001 \
+       --min-lr 0.00001 \
+       --lr-decay-style linear \
+       --lr-warmup-fraction .01 \
+       --weight-decay 1e-2 \
+       --clip-grad 1.0 \
+       --log-interval 100 \
+       --save-interval 10000 \
+       --eval-interval 1000 \
+       --eval-iters 10 \
+       --fp16

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/examples/pretrain_t5_distributed.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+
+GPUS_PER_NODE=8
+# Change for multinode config
+MASTER_ADDR=localhost
+MASTER_PORT=6000
+NNODES=1
+NODE_RANK=0
+WORLD_SIZE=$(($GPUS_PER_NODE*$NNODES))
+
+DATA_PATH=<Specify path and file prefix>
+VOCAB_FILE=<Specify path to vocab.txt>
+CHECKPOINT_PATH=<Specify path>
+
+DISTRIBUTED_ARGS="--nproc_per_node $GPUS_PER_NODE --nnodes $NNODES --node_rank $NODE_RANK --master_addr $MASTER_ADDR --master_port $MASTER_PORT"
+
+python -m torch.distributed.launch $DISTRIBUTED_ARGS \
+       pretrain_t5.py \
+       --num-layers 12 \
+       --hidden-size 768 \
+       --num-attention-heads 12 \
+       --kv-channels 64 \
+       --ffn-hidden-size 3072 \
+       --encoder-seq-length 512 \
+       --decoder-seq-length 128 \
+       --micro-batch-size 16 \
+       --global-batch-size 2048 \
+       --max-position-embeddings 512 \
+       --train-iters 1000000 \
+       --lr-decay-iters 1000000 \
+       --save $CHECKPOINT_PATH \
+       --load $CHECKPOINT_PATH \
+       --data-path $DATA_PATH \
+       --vocab-file $VOCAB_FILE \
+       --data-impl mmap \
+       --split 949,50,1 \
+       --lr 0.0001 \
+       --min-lr 0.00001 \
+       --lr-decay-style linear \
+       --lr-warmup-fraction .01 \
+       --weight-decay 1e-2 \
+       --clip-grad 1.0 \
+       --log-interval 100 \
+       --save-interval 10000 \
+       --eval-interval 1000 \
+       --eval-iters 10 \
+       --fp16

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/examples/pretrain_t5_distributed_with_mp.sh

@@ -0,0 +1,48 @@
+#!/bin/bash
+
+GPUS_PER_NODE=8
+# Change for multinode config
+MASTER_ADDR=localhost
+MASTER_PORT=6000
+NNODES=1
+NODE_RANK=0
+WORLD_SIZE=$(($GPUS_PER_NODE*$NNODES))
+
+DATA_PATH=<Specify path and file prefix>
+CHECKPOINT_PATH=<Specify path>
+
+DISTRIBUTED_ARGS="--nproc_per_node $GPUS_PER_NODE --nnodes $NNODES --node_rank $NODE_RANK --master_addr $MASTER_ADDR --master_port $MASTER_PORT"
+
+python -m torch.distributed.launch $DISTRIBUTED_ARGS \
+       pretrain_t5.py \
+       --tensor-model-parallel-size 2 \
+       --num-layers 12 \
+       --hidden-size 768 \
+       --num-attention-heads 12 \
+       --kv-channels 64 \
+       --ffn-hidden-size 3072 \
+       --encoder-seq-length 512 \
+       --decoder-seq-length 128 \
+       --micro-batch-size 16 \
+       --global-batch-size 2048 \
+       --seq-length 512 \
+       --max-position-embeddings 512 \
+       --train-iters 1000000 \
+       --lr-decay-iters 1000000 \
+       --save $CHECKPOINT_PATH \
+       --load $CHECKPOINT_PATH \
+       --data-path $DATA_PATH \
+       --vocab-file t5-vocab.txt \
+       --data-impl mmap \
+       --split 949,50,1 \
+       --lr 0.0001 \
+       --min-lr 0.00001 \
+       --lr-decay-style linear \
+       --lr-warmup-fraction .01 \
+       --weight-decay 1e-2 \
+       --clip-grad 1.0 \
+       --log-interval 100 \
+       --save-interval 10000 \
+       --eval-interval 1000 \
+       --eval-iters 10 \
+       --fp16

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/pretrain_bert.py

@@ -0,0 +1,159 @@
+# coding=utf-8
+# Copyright (c) 2023 Habana Labs, Ltd. an Intel Company.
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Pretrain BERT"""
+
+from functools import partial
+
+import torch
+import torch.nn.functional as F
+
+from megatron import get_args
+from megatron import print_rank_0
+from megatron import get_timers
+from megatron import mpu
+from megatron.data.dataset_utils import build_train_valid_test_datasets
+from megatron.model import BertModel
+from megatron.training import pretrain
+from megatron.utils import average_losses_across_data_parallel_group
+
+
+def model_provider(pre_process=True, post_process=True):
+    """Build the model."""
+
+    print_rank_0('building BERT model ...')
+
+    args = get_args()
+    num_tokentypes = 2 if args.bert_binary_head else 0
+    model = BertModel(
+        num_tokentypes=num_tokentypes,
+        add_binary_head=args.bert_binary_head,
+        parallel_output=True,
+        pre_process=pre_process,
+        post_process=post_process)
+
+    return model
+
+
+def get_batch(data_iterator):
+    """Build the batch."""
+
+    # Items and their type.
+    keys = ['text', 'types', 'labels', 'is_random', 'loss_mask', 'padding_mask']
+    datatype = torch.int64 if get_args.device.type=="cuda" else torch.int32
+
+    # Broadcast data.
+    if data_iterator is not None:
+        data = next(data_iterator)
+        # TODO (SW-62395): Implement proper Long -> Int casting
+        for key, val in data.items():
+            data[key] = val.to(datatype)
+    else:
+        data = None
+    data_b = mpu.broadcast_data(keys, data, datatype)
+
+    # Unpack.
+    if (datatype == torch.int64):
+        tokens = data_b['text'].long()
+        types = data_b['types'].long()
+        sentence_order = data_b['is_random'].long()
+        loss_mask = data_b['loss_mask'].float()
+        lm_labels = data_b['labels'].long()
+        padding_mask = data_b['padding_mask'].long()
+    else:
+        tokens = data_b['text'].int()
+        types = data_b['types'].int()
+        sentence_order = data_b['is_random'].int()
+        loss_mask = data_b['loss_mask'].float()
+        lm_labels = data_b['labels'].int()
+        padding_mask = data_b['padding_mask'].int()
+
+    return tokens, types, sentence_order, loss_mask, lm_labels, padding_mask
+
+
+def loss_func(loss_mask, sentence_order, output_tensor):
+    lm_loss_, sop_logits = output_tensor
+
+    lm_loss_ = lm_loss_.float()
+    loss_mask = loss_mask.float()
+    lm_loss = torch.sum(
+        lm_loss_.view(-1) * loss_mask.reshape(-1)) / loss_mask.sum()
+
+    if sop_logits is not None:
+        sop_loss = F.cross_entropy(sop_logits.view(-1, 2).float(),
+                                   sentence_order.view(-1),
+                                   ignore_index=-1)
+        sop_loss = sop_loss.float()
+        loss = lm_loss + sop_loss
+        averaged_losses = average_losses_across_data_parallel_group(
+            [lm_loss, sop_loss])
+        return loss, {'lm loss': averaged_losses[0],
+                      'sop loss': averaged_losses[1]}
+
+    else:
+        loss = lm_loss
+        averaged_losses = average_losses_across_data_parallel_group(
+            [lm_loss])
+        return loss, {'lm loss': averaged_losses[0]}
+
+
+def forward_step(data_iterator, model):
+    """Forward step."""
+    args = get_args()
+    timers = get_timers()
+
+    # Get the batch.
+    timers('batch-generator').start()
+    tokens, types, sentence_order, loss_mask, lm_labels, padding_mask = get_batch(
+        data_iterator)
+    timers('batch-generator').stop()
+
+    if not args.bert_binary_head:
+        types = None
+
+    # Forward pass through the model.
+    output_tensor = model(tokens, padding_mask, tokentype_ids=types,
+                          lm_labels=lm_labels)
+
+    return output_tensor, partial(loss_func, loss_mask, sentence_order)
+
+
+def train_valid_test_datasets_provider(train_val_test_num_samples):
+    """Build train, valid, and test datasets."""
+    args = get_args()
+
+    print_rank_0('> building train, validation, and test datasets '
+                 'for BERT ...')
+    train_ds, valid_ds, test_ds = build_train_valid_test_datasets(
+        data_prefix=args.data_path,
+        data_impl=args.data_impl,
+        splits_string=args.split,
+        train_valid_test_num_samples=train_val_test_num_samples,
+        max_seq_length=args.seq_length,
+        masked_lm_prob=args.mask_prob,
+        short_seq_prob=args.short_seq_prob,
+        seed=args.seed,
+        skip_warmup=(not args.mmap_warmup),
+        binary_head=args.bert_binary_head)
+    print_rank_0("> finished creating BERT datasets ...")
+
+    return train_ds, valid_ds, test_ds
+
+
+if __name__ == "__main__":
+
+    pretrain(train_valid_test_datasets_provider, model_provider, forward_step,
+             args_defaults={'tokenizer_type': 'BertWordPieceLowerCase'})

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/pretrain_gpt.py

@@ -0,0 +1,335 @@
+# coding=utf-8
+# Copyright (c) 2023 Habana Labs, Ltd. an Intel Company.
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Pretrain GPT"""
+
+import torch
+from functools import partial
+from megatron import get_args
+from megatron import print_rank_0
+from megatron import get_timers
+from megatron import get_tokenizer
+from megatron import mpu
+from megatron.data.gpt_dataset import build_train_valid_test_datasets
+from megatron.model import GPTModel, GPTModelPipe
+from megatron.training import pretrain
+from megatron.utils import get_ltor_masks_and_position_ids
+from megatron.utils import average_losses_across_data_parallel_group
+from megatron.global_vars import get_current_device
+from megatron.enums import PositionEmbeddingType
+import deepspeed
+from deepspeed.runtime.utils import see_memory_usage
+import os
+import subprocess
+
+from torch import nn
+import torch.nn.functional as F
+
+def model_provider(pre_process=True, post_process=True, parallel_output=True):
+    """Build the model."""
+
+    print_rank_0('building GPT model ...')
+    see_memory_usage(f"Before Building Model", force=True)
+
+    args = get_args()
+    with deepspeed.zero.Init(data_parallel_group=mpu.get_data_parallel_group(),
+                             remote_device=None if args.remote_device == 'none' else args.remote_device,
+                             config_dict_or_path=args.deepspeed_config,
+                             enabled=args.zero_stage == 3,
+                             mpu=mpu):
+        current_device = get_current_device()
+        if args.deepspeed and not args.no_pipeline_parallel:
+
+            # verify --deepspeed_activation_checkpointing
+            # mandatory! otherwise the model uses fork() mapping to Megatron's RNGStatesTrackerSingleton
+            # while GPTModelPipe uses DS checkpoint activations that uses DS's RNGStatesTracker
+            if args.checkpoint_activations and args.checkpoint_activations_granularity == "full":
+                assert args.deepspeed_activation_checkpointing, \
+                    "Flag --deepspeed_activation_checkpointing is mandatory when using GPTModelPipe" \
+                    " with checkpoint activations granularity full."
+
+            model = GPTModelPipe(
+                num_tokentypes=0,
+                parallel_output=parallel_output,
+            )
+            # This is a hack to give us a reference to get_batch_pipe from within training.py
+            # We need to call model.set_batch_fn after deepspeed.initialize
+            model._megatron_batch_fn = get_batch_pipe
+
+            # Predompute the attention mask and store it in args. This avoids having to
+            # pipeline it as an activation during training. The mask is constant, and thus
+            # we can reuse it.
+            attention_mask = torch.tril(torch.ones(
+                (1, args.seq_length, args.seq_length), device=current_device)).view(
+                    1, 1, args.seq_length, args.seq_length)
+
+            # Convert attention mask to binary:
+            attention_mask = (attention_mask < 0.5)
+            if args.fp16:
+                attention_mask = attention_mask.half()
+            elif args.bf16:
+                attention_mask = attention_mask.bfloat16()
+
+            if args.mask_tensor_adding:
+                args.attn_mask = attention_mask * -10000.0
+            else:
+                args.attn_mask = attention_mask.to(torch.bool)
+
+        else:
+            assert args.position_embedding_type != PositionEmbeddingType.alibi, \
+                "GPTModel doesn't yet support ALiBi positional encoding"
+            model = GPTModel(
+                num_tokentypes=0,
+                parallel_output=parallel_output,
+                pre_process=pre_process,
+                post_process=post_process
+            ).to(current_device)
+    see_memory_usage(f"After Building Model", force=True)
+    return model
+
+
+def get_batch(data_iterator):
+    """Generate a batch"""
+    args = get_args()
+    tokenizer = get_tokenizer()
+
+    # Items and their type.
+    keys = ['text']
+    datatype = torch.int64
+
+    # Broadcast data.
+    if data_iterator is not None:
+        data = next(data_iterator)
+    else:
+        data = None
+    data_b = mpu.broadcast_data(keys, data, datatype)
+
+    # Unpack.
+    tokens_ = data_b['text'].long()
+    if not args.use_seq_len_plus_one_tokens:
+        labels = torch.roll(tokens_, shifts=-1, dims=1)
+        labels[:, -1] = -1
+        tokens = tokens_
+    else:
+        labels = tokens_[:, 1:].contiguous()
+        tokens = tokens_[:, :-1].contiguous()
+
+    # Get the masks and postition ids.
+    attention_mask, loss_mask, position_ids = get_ltor_masks_and_position_ids(
+        tokens,
+        tokenizer.eod,
+        args.reset_position_ids,
+        args.reset_attention_mask,
+        args.eod_mask_loss,
+        labels = labels,
+        dummy_sample= None,)
+
+    tokens[tokens == -1] = 0
+    labels[labels == -1] = 0
+
+    return tokens, labels, loss_mask, attention_mask, position_ids
+
+
+def get_batch_pipe(data):
+    """Modification of `get_batch` to work on `next(data_iterator)` instead of `data_iterator`"""
+    args = get_args()
+    tokenizer = get_tokenizer()
+
+    # Items and their type.
+    keys = ['text']
+    datatype = torch.int64
+
+    # Broadcast data.
+    data_b = mpu.broadcast_data(keys, data, datatype)
+
+    # Unpack.
+    tokens_ = data_b['text'].long()
+    if not args.use_seq_len_plus_one_tokens:
+        labels = torch.roll(tokens_, shifts=-1, dims=1)
+        labels[:, -1] = -1
+        tokens = tokens_
+    else:
+        labels = tokens_[:, 1:].contiguous()
+        tokens = tokens_[:, :-1].contiguous()
+
+    # Get the masks and postition ids.
+    attention_mask, loss_mask, position_ids = get_ltor_masks_and_position_ids(
+        tokens,
+        tokenizer.eod,
+        args.reset_position_ids,
+        args.reset_attention_mask,
+        args.eod_mask_loss,
+        labels = labels,
+        dummy_sample = None,
+        )
+    tokens[tokens == -1] = 0
+    labels[labels == -1] = 0
+
+
+    if args.curriculum_learning and args.curriculum_seqlen < tokens.size()[1]:
+        # seqlen-based curriculum learning
+        # tokens, position_ids, labels, loss_mask have size [batch size, seqlen]
+        tokens = tokens[:, :args.curriculum_seqlen].contiguous()
+        position_ids = position_ids[:, :args.curriculum_seqlen].contiguous()
+        if labels is not None:
+            labels = labels[:, :args.curriculum_seqlen].contiguous()
+        loss_mask = loss_mask[:, :args.curriculum_seqlen].contiguous()
+
+    return (tokens, position_ids, attention_mask), (labels, loss_mask)
+
+
+def loss_func(loss_mask, moe_loss, mos_loss, output_tensor):
+    args = get_args()
+    losses = output_tensor.float()
+    loss_mask = loss_mask.view(-1).float()
+    loss = torch.sum(losses.view(-1) * loss_mask) / loss_mask.sum()
+    
+    # Reduce loss for logging.
+    averaged_loss = average_losses_across_data_parallel_group([loss])
+    if args.mos or args.kd:
+        # assert max(args.num_experts) >= 1
+        loss = loss + moe_loss + mos_loss
+        if args.mos:
+            return loss, {'total loss': loss, 'lm loss': averaged_loss[0], 'moe loss': moe_loss, 'mos loss': mos_loss}
+        elif args.kd:
+            return loss, {'total loss': loss, 'lm loss': averaged_loss[0], 'moe loss': moe_loss, 'kd loss': mos_loss}
+        print_rank_0('>>> total loss: {}, lm loss {}, kd loss {}'.format(loss, averaged_loss[0], mos_loss))
+    else:
+        if max(args.num_experts) <= 1:
+            return loss, {'lm loss': averaged_loss[0]}
+        else:
+            loss = loss + moe_loss
+            return loss, {'lm loss': averaged_loss[0], 'moe loss': moe_loss}
+
+def calculate_mos_loss(args, stu_output, teacher_model, tokens, position_ids, attention_mask):
+    mos_loss = 0
+    alpha = args.kd_alpha_ce
+    beta = args.kd_beta_ce
+    kd_temp = args.kd_temp
+    
+    if teacher_model:
+        with torch.no_grad():
+            if args.curriculum_learning and args.curriculum_seqlen < args.seq_length:
+                assert args.curriculum_seqlen is not None
+                curriculum_seqlen = args.curriculum_seqlen
+                tokens = tokens[:, :curriculum_seqlen].contiguous()
+                position_ids = position_ids[:, :curriculum_seqlen].contiguous()
+                attention_mask = attention_mask[:, :, :curriculum_seqlen, :curriculum_seqlen].contiguous()
+                # No need to truncate labels as we do not need it for the teacher logits
+            tea_output, *tea_other_losses = teacher_model(tokens, position_ids, attention_mask)
+            assert stu_output.size() == tea_output.size(), 'teacher and student output should match in size. Student: {}, Teacher: {}, CL seq length {}'.format(stu_output.size(), tea_output.size(), args.curriculum_seqlen)
+
+        student_logits = F.log_softmax(stu_output / kd_temp, dim=2)
+        tea_logits = F.softmax(tea_output / kd_temp, dim=2) # The target logits is expected to be probabilities. If we use log_softmax, then we need to set target_log to true when initializing the KLDivLoss.
+
+        mos_loss = kd_temp * kd_temp * nn.KLDivLoss(reduction='batchmean')(student_logits, tea_logits)
+
+        mos_loss = mos_loss.div(args.seq_length) * beta
+    return mos_loss
+
+def forward_step(data_iterator, model, teacher_model=None):
+    """Forward step."""
+    args = get_args()
+    timers = get_timers()
+
+    # Get the batch.
+    timers('batch-generator').start()
+    tokens, labels, loss_mask, attention_mask, position_ids = get_batch(
+        data_iterator)
+    timers('batch-generator').stop()
+
+    if args.mos or args.kd:
+        # The forward func can return either the loss or the logits, depending on whether passing in the labels or not.
+        stu_output, *other_losses = model(tokens, position_ids, attention_mask)
+        if args.curriculum_learning and args.curriculum_seqlen < args.seq_length:
+            assert args.curriculum_seqlen is not None
+            labels = labels[:, :args.curriculum_seqlen].contiguous()
+        output_tensor = mpu.vocab_parallel_cross_entropy(stu_output.contiguous().float(), labels)
+    else:
+        output_tensor, *other_losses = model(tokens, position_ids, attention_mask,
+                                            labels=labels)
+    if args.curriculum_learning and args.curriculum_seqlen < args.seq_length:
+        loss_mask = loss_mask[:, :args.curriculum_seqlen].contiguous()
+
+    moe_losses = []
+    for moe_loss in other_losses:
+        if moe_loss is not None:
+            moe_losses.append(moe_loss)
+    moe_loss = sum(moe_losses) * args.moe_loss_coeff
+
+    mos_loss = 0
+    if args.mos or args.kd:
+        assert model.training
+        mos_loss = calculate_mos_loss(args, stu_output, teacher_model, tokens, position_ids, attention_mask)
+    
+    # Output_tensor stores the standard loss, loos_func calculates the total loss.
+    return output_tensor, partial(loss_func, loss_mask, moe_loss, mos_loss)
+
+
+def train_valid_test_datasets_provider(train_val_test_num_samples):
+    """Build train, valid, and test datasets."""
+    args = get_args()
+
+    print_rank_0('> building train, validation, and test datasets '
+                 'for GPT ...')
+    train_ds, valid_ds, test_ds = build_train_valid_test_datasets(
+        data_prefix=args.data_path,
+        train_data_prefix=args.train_data_path,
+        valid_data_prefix=args.valid_data_path,
+        test_data_prefix=args.test_data_path,
+        data_impl=args.data_impl,
+        splits_string=args.split,
+        train_valid_test_num_samples=train_val_test_num_samples,
+        seq_length=args.seq_length,
+        seed=args.seed,
+        skip_warmup=(not args.mmap_warmup),
+        use_seq_len_plus_one_tokens=args.use_seq_len_plus_one_tokens)
+    print_rank_0("> finished creating GPT datasets ...")
+
+    return train_ds, valid_ds, test_ds
+
+
+def command_exists(cmd):
+    result = subprocess.Popen(f'type {cmd}', stdout=subprocess.PIPE, shell=True)
+    return result.wait() == 0
+
+
+def git_ds_info():
+    from deepspeed.env_report import main as ds_report
+    ds_report()
+
+    # Write out version/git info
+    git_hash_cmd = "git rev-parse --short HEAD"
+    git_branch_cmd = "git rev-parse --abbrev-ref HEAD"
+    if command_exists('git'):
+        try:
+            result = subprocess.check_output(git_hash_cmd, shell=True)
+            git_hash = result.decode('utf-8').strip()
+            result = subprocess.check_output(git_branch_cmd, shell=True)
+            git_branch = result.decode('utf-8').strip()
+        except subprocess.CalledProcessError:
+            git_hash = "unknown"
+            git_branch = "unknown"
+    else:
+        git_hash = "unknown"
+        git_branch = "unknown"
+    print(f'**** Git info for Megatron: git_hash={git_hash} git_branch={git_branch} ****')
+
+
+if __name__ == "__main__":
+    git_ds_info()
+    pretrain(train_valid_test_datasets_provider, model_provider, forward_step,
+             args_defaults={'tokenizer_type': 'GPT2BPETokenizer'})

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/pretrain_ict.py

@@ -0,0 +1,167 @@
+# coding=utf-8
+# Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Pretrain BERT for Inverse Cloze Task"""
+import math
+
+import torch
+import torch.distributed as dist
+import torch.nn.functional as F
+
+from megatron import get_args
+from megatron import print_rank_0
+from megatron import get_timers
+from megatron import mpu
+from megatron.data.biencoder_dataset_utils import get_ict_batch
+from megatron.data.dataset_utils import build_train_valid_test_datasets
+from megatron.model.biencoder_model import biencoder_model_provider
+from megatron.training import pretrain
+from megatron.utils import average_losses_across_data_parallel_group
+
+
+def pretrain_ict_model_provider():
+    args = get_args()
+    model = biencoder_model_provider(
+                only_context_model=False,
+                only_query_model=False,
+                biencoder_shared_query_context_model=\
+                    args.biencoder_shared_query_context_model)
+    return model
+
+def get_group_world_size_rank():
+
+    group = mpu.get_data_parallel_group()
+    rank = torch.distributed.get_rank(group=group)
+    world_size = torch.distributed.get_world_size(group=group)
+
+    return group, rank, world_size
+
+
+class AllgatherFromDataParallelRegion(torch.autograd.Function):
+
+    @staticmethod
+    def forward(ctx, input_):
+        assert input_.dim() == 2
+        group, rank, world_size = get_group_world_size_rank()
+
+        tensor_list = [torch.empty_like(input_) for _ in range(world_size)]
+        tensor_list[rank] = input_
+        torch.distributed.all_gather(tensor_list, input_, group=group)
+
+        output = torch.cat(tensor_list, dim=0).contiguous()
+
+        return output
+
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        group, rank, world_size = get_group_world_size_rank()
+
+        assert grad_output.shape[0] % world_size == 0
+        dim_size = grad_output.shape[0] // world_size
+        output_list = torch.split(grad_output, dim_size, dim=0)
+
+        # get chunk from this rank
+        output = output_list[rank].contiguous()
+        return output
+
+def forward_step(data_iterator, model, input_tensor):
+    """Forward step."""
+    args = get_args()
+    timers = get_timers()
+
+    # Get the batch.
+    timers('batch-generator').start()
+    query_tokens, query_mask, \
+    context_tokens, context_mask, context_indices = get_ict_batch(data_iterator)
+    timers('batch-generator').stop()
+
+    # Query and Context Types
+    query_types = torch.cuda.LongTensor(*query_tokens.shape).fill_(0)
+    context_types = torch.cuda.LongTensor(*context_tokens.shape).fill_(0)
+
+    # Forward model.
+    query_logits, context_logits = model(query_tokens, query_mask,
+                                    query_types, context_tokens,
+                                    context_mask, context_types)
+
+    micro_batch_size = query_logits.shape[0]
+    # recall we assert that tensor_model_parallel_size == 1
+    assert mpu.get_tensor_model_parallel_world_size() == 1, \
+        "Model parallel size > 1 not supported for ICT"
+
+    global_batch_size = dist.get_world_size() * micro_batch_size
+    all_query_logits = AllgatherFromDataParallelRegion.apply(query_logits)
+    all_context_logits = AllgatherFromDataParallelRegion.apply(context_logits)
+
+    # scores are inner products between query and context embeddings
+    retrieval_scores = torch.matmul(all_query_logits,
+                        torch.transpose(all_context_logits, 0, 1))
+    # scaling the retriever scores
+    if args.retriever_score_scaling:
+        retrieval_scores = retrieval_scores / math.sqrt(args.hidden_size)
+
+    softmax_scores = F.log_softmax(retrieval_scores, dim=1)
+    sorted_vals, sorted_indices = torch.topk(softmax_scores,
+                                    k=softmax_scores.shape[1], sorted=True)
+
+    def topk_accuracy(k):
+        return torch.cuda.FloatTensor([sum([int(i in sorted_indices[i, :k]) \
+            for i in range(global_batch_size)]) / global_batch_size])
+
+    topk_accs = [topk_accuracy(int(k)) for k in args.retriever_report_topk_accuracies]
+
+    labels = torch.arange(global_batch_size).long().cuda()
+    loss = F.nll_loss(softmax_scores, labels, reduction='mean')
+    reduced_losses = average_losses_across_data_parallel_group([loss, *topk_accs])
+
+    # Scale the retrieval loss
+    loss = loss * mpu.get_data_parallel_world_size()
+
+    # create stats_dict with retrieval loss and all specified top-k accuracies
+    topk_acc_dict = {'top{}_acc'.format(k): v * 100 for k, v in \
+                        zip(args.retriever_report_topk_accuracies, reduced_losses[1:])}
+    stats_dict = dict(loss=reduced_losses[0], **topk_acc_dict)
+    return loss, stats_dict
+
+
+def train_valid_test_datasets_provider(train_val_test_num_samples):
+    """Build train, valid and test datasets."""
+    args = get_args()
+    print_rank_0('> building train, validation, and test datasets '
+                 'for BERT ICT...')
+
+    train_ds, valid_ds, test_ds = build_train_valid_test_datasets(
+        data_prefix=args.data_path,
+        data_impl=args.data_impl,
+        splits_string=args.split,
+        train_valid_test_num_samples=train_val_test_num_samples,
+        max_seq_length=args.seq_length,
+        masked_lm_prob=args.mask_prob,
+        short_seq_prob=args.short_seq_prob,
+        seed=args.seed,
+        skip_warmup=(not args.mmap_warmup),
+        binary_head=False,
+        dataset_type='ict')
+    print_rank_0("> finished creating BERT ICT datasets ...")
+
+    return train_ds, valid_ds, test_ds
+
+
+if __name__ == "__main__":
+    pretrain(train_valid_test_datasets_provider,
+             pretrain_ict_model_provider,
+             forward_step,
+             args_defaults={'tokenizer_type': 'BertWordPieceLowerCase'})

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/pretrain_t5.py

@@ -0,0 +1,134 @@
+# coding=utf-8
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Pretrain T5"""
+
+from functools import partial
+
+import torch
+
+from megatron import (
+    get_args,
+    get_timers,
+    mpu,
+    print_rank_0
+)
+from megatron.data.dataset_utils import build_train_valid_test_datasets
+from megatron.model import T5Model
+from megatron.training import pretrain
+from megatron.utils import average_losses_across_data_parallel_group
+
+
+def model_provider(pre_process=True, post_process=True):
+    """Build the model."""
+    assert pre_process and post_process, "T5 doesn't yet support pipelining"
+
+    print_rank_0('building T5 model ...')
+    model = T5Model(num_tokentypes=0,
+                    parallel_output=True)
+    return model
+
+
+def get_batch(data_iterator):
+    """Build the batch."""
+
+    keys = ['text_enc', 'text_dec', 'labels', 'loss_mask',
+            'enc_mask', 'dec_mask', 'enc_dec_mask']
+    datatype = torch.int64
+
+    # Broadcast data.
+    if data_iterator is not None:
+        data = next(data_iterator)
+    else:
+        data = None
+    data_b = mpu.broadcast_data(keys, data, datatype)
+
+    # Unpack.
+    tokens_enc = data_b['text_enc'].long()
+    tokens_dec = data_b['text_dec'].long()
+    labels = data_b['labels'].long()
+    loss_mask = data_b['loss_mask'].float()
+
+    enc_mask = (data_b['enc_mask'] < 0.5)
+    dec_mask = (data_b['dec_mask'] < 0.5)
+    enc_dec_mask = (data_b['enc_dec_mask'] < 0.5)
+
+    return tokens_enc, tokens_dec, loss_mask, labels, \
+           enc_mask, dec_mask, enc_dec_mask
+
+
+def loss_func(loss_mask, output_tensor):
+    lm_loss_, _ = output_tensor
+
+    lm_loss_ = lm_loss_.float()
+    lm_loss = torch.sum(
+        lm_loss_.view(-1) * loss_mask.reshape(-1)) / loss_mask.sum()
+
+    loss = lm_loss
+    averaged_losses = average_losses_across_data_parallel_group([lm_loss])
+
+    return loss, {'lm loss': averaged_losses[0]}
+
+
+def forward_step(data_iterator, model):
+    """Forward step."""
+    args = get_args()
+    timers = get_timers()
+
+    # Get the batch.
+    timers('batch generator').start()
+    tokens_enc, tokens_dec, loss_mask, lm_labels, enc_mask, dec_mask, enc_dec_mask \
+        = get_batch(data_iterator)
+    timers('batch generator').stop()
+
+    # Forward model lm_labels
+    output_tensor = model(tokens_enc,
+                          tokens_dec,
+                          enc_mask,
+                          dec_mask,
+                          enc_dec_mask,
+                          tokentype_ids=None,
+                          lm_labels=lm_labels)
+
+    return output_tensor, partial(loss_func, loss_mask)
+
+
+def train_valid_test_datasets_provider(train_val_test_num_samples):
+    """Build train, valid, and test datasets."""
+    args = get_args()
+
+    print_rank_0('> building train, validation, and test datasets '
+                 'for T5 ...')
+    train_ds, valid_ds, test_ds = build_train_valid_test_datasets(
+        data_prefix=args.data_path,
+        data_impl=args.data_impl,
+        splits_string=args.split,
+        train_valid_test_num_samples=train_val_test_num_samples,
+        max_seq_length=args.encoder_seq_length,
+        max_seq_length_dec=args.decoder_seq_length,
+        masked_lm_prob=args.mask_prob,
+        short_seq_prob=args.short_seq_prob,
+        seed=args.seed,
+        skip_warmup=(not args.mmap_warmup),
+        dataset_type='t5')
+    print_rank_0("> finished creating T5 datasets ...")
+
+    return train_ds, valid_ds, test_ds
+
+
+if __name__ == "__main__":
+
+    pretrain(train_valid_test_datasets_provider, model_provider, forward_step,
+             args_defaults={'tokenizer_type': 'BertWordPieceLowerCase'})

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/pretrain_vit.py

@@ -0,0 +1,91 @@
+# coding=utf-8
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Pretrain VIT"""
+
+import torch
+import torch.nn.functional as F
+from megatron import get_args, get_timers, mpu, print_rank_0
+from megatron.data.vit_dataset import build_train_valid_datasets
+from megatron.model.vit_model import VitModel
+from megatron.training import pretrain
+from megatron.utils import average_losses_across_data_parallel_group
+
+def model_provider():
+    """Build the model."""
+
+    print_rank_0("building VIT model ...")
+    args = get_args()
+
+    model = VitModel(num_classes=args.num_classes)
+    return model
+
+def get_batch(data_iterator):
+    """Build the batch."""
+    data = next(data_iterator)
+
+    # only data parallelism; no need for broadcast
+    images = data[0].cuda()
+    labels = data[1].cuda()
+
+    return images, labels
+
+def forward_step(data_iterator, model, input_tensor):
+    """Forward step."""
+    timers = get_timers()
+    assert input_tensor is None
+
+    # Get the batch.
+    timers("batch-generator").start()
+    (
+        images,
+        labels,
+    ) = get_batch(data_iterator)
+    timers("batch-generator").stop()
+
+    # Forward model. lm_labels
+    logits = model(images).contiguous().float()
+    loss = F.cross_entropy(logits, labels)
+
+    outputs = torch.argmax(logits, -1)
+    correct = (outputs == labels).float()
+    accuracy = torch.mean(correct)
+
+    averaged_loss = average_losses_across_data_parallel_group([loss, accuracy])
+
+    return loss, {"loss": averaged_loss[0], "accuracy": averaged_loss[1]}
+
+
+def train_valid_test_datasets_provider(train_val_test_num_samples):
+    """Build train, valid, and test datasets."""
+    args = get_args()
+
+    print_rank_0(
+        "> building train, validation, and test datasets " "for VIT ..."
+    )
+    train_ds, valid_ds = build_train_valid_datasets(data_path=args.data_path)
+    print_rank_0("> finished creating VIT datasets ...")
+
+    return train_ds, valid_ds, None
+
+
+if __name__ == "__main__":
+
+    pretrain(
+        train_valid_test_datasets_provider,
+        model_provider,
+        forward_step,
+        args_defaults={'dataloader_type': 'cyclic'}
+    )

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/requirements.txt

@@ -0,0 +1,10 @@
+git+https://github.com/mlcommons/[email protected]
+git+https://github.com/NVIDIA/mlperf-common.git
+pybind11
+torch
+six
+regex
+numpy
+sentencepiece
+torchmetrics>=0.8.0
+einops

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/run_gpt.sh

@@ -0,0 +1,433 @@
+#!/bin/bash
+# Copyright (c) 2023 Habana Labs, Ltd. an Intel Company.
+
+set -ex
+function parse_args()
+{
+    while true; do
+        case "$1" in
+            --data-dir )
+                DATA_DIR="$2"
+                shift 2 ;;
+            --num-nodes )
+                NUM_NODES="$2"
+                shift 2 ;;
+            --devices-per-node )
+                DEVICES_PER_NODE="$2"
+                shift 2 ;;
+            --data-parallel-size )
+                DP="$2"
+                shift 2 ;;
+            --tensor-model-parallel-size )
+                TP="$2"
+                shift 2 ;;
+            --pipeline-model-parallel-size )
+                PP="$2"
+                shift 2 ;;
+            --num-layers )
+                NUM_LAYERS="$2"
+                shift 2 ;;
+            --hidden-size )
+                HIDDEN_SIZE="$2"
+                shift 2 ;;
+            --num-attention-heads )
+                NUM_ATTENTION_HEADS="$2"
+                shift 2 ;;
+            --seq-length )
+                SEQ_LENGTH="$2"
+                shift 2 ;;
+            --dropout )
+                DROPOUT="$2"
+                shift 2 ;;
+            --micro-batch-size )
+                MICRO_BATCH="$2"
+                shift 2 ;;
+            --eval-micro-batch-size )
+                EVAL_MICRO_BATCH="$2"
+                shift 2 ;;
+            --global-batch-size )
+                GLOBAL_BATCH="$2"
+                shift 2 ;;
+            --train-samples )
+                TRAIN_SAMPLES="$2"
+                shift 2 ;;
+            --lr )
+                LR="$2"
+                shift 2 ;;
+            --min-lr )
+                MIN_LR="$2"
+                shift 2 ;;
+            --lr-decay-samples )
+                LR_DECAY_SAMPLES="$2"
+                shift 2 ;;
+            --lr-warmup-samples )
+                LR_WARMUP_SAMPLES="$2"
+                shift 2 ;;
+            --seed )
+                SEED="$2"
+                shift 2 ;;
+            --eval-iters )
+                EVAL_ITERS="$2"
+                shift 2 ;;
+            --eval-interval )
+                EVAL_INTERVAL="$2"
+                shift 2 ;;
+            --exit-interval )
+                EXIT_INTERVAL="$2"
+                shift 2 ;;
+            --output-dir )
+                OUTPUT_DIR="$2"
+                shift 2 ;;
+            --start-from-ckpt )
+                START_FROM_CKPT="$2"
+                shift 2 ;;
+            --universal-ckpt-path )
+                UNIVERSAL_CKPT_PATH="$2"
+                shift 2 ;;
+            --save-checkpoints )
+                SAVE_CKPT="$2"
+                shift 2 ;;
+            --save-checkpoints-dir )
+                SAVE_CKPT_DIR="$2"
+                shift 2 ;;
+            --save-interval )
+                SAVE_INTERVAL="$2"
+                shift 2 ;;
+            --log-interval )
+                LOG_INTERVAL="$2"
+                shift 2 ;;
+            --tensorboard-dir )
+                TENSORBOARD_DIR="$2"
+                shift 2 ;;
+            --kill-switch-file )
+                KILL_SWITCH_FILE="$2"
+                shift 2 ;;
+            --hosts )
+                HOSTS="$2"
+                shift 2 ;;
+            --hostsfile )
+                HOSTSFILE="$2"
+                shift 2 ;;
+            --mllog-output-path )
+                MLLOG_FILE="$2"
+                shift 2 ;;
+            --eval-loss-exit-value )
+                EVAL_LOSS_EXIT_VALUE="$2"
+                shift 2 ;;
+            --profile )
+                PROFILE_FLAG="--profile $2"
+                shift 2 ;;
+            --profile-steps )
+                PROFILE_STEPS_FLAG="--profile-steps $2"
+                shift 2 ;;
+            -te | --use-fp8-transformer-engine )
+                TRANSFORMER_ENGINE_FLAG="--use-hpu-fp8-transformer-engine"
+                shift 1 ;;
+            -fsdpa | --use-fused-sdpa )
+                USE_FUSED_SDPA="--use-fused-sdpa $2"
+                shift 2 ;;
+            -fsdpa-recompute | --use-fused-sdpa-with-recompute )
+                USE_FUSED_SDPA_WITH_RECOMPUTE_ARG="$2"
+                shift 2 ;;
+            --fp8-measure-interval )
+                FP8_MEASURE_INTERVAL="$2"
+                shift 2 ;;
+            --use-hpu-graphs )
+                HPU_GRAPHS_FLAG="--use-hpu-graphs $2"
+                shift 2 ;;
+            --cache-fp8-weight-fwd )
+                HPU_GRAPHS_FLAG="--cache-fp8-weight-fwd $2"
+                shift 2 ;;
+            --ext-train-iters )
+                EXTERNAL_TRAINING_ITERATIONS="$2"
+                shift 2 ;;
+            -sp | --sequence-parallel )
+                SEQUENCE_PARALLEL="$2"
+                shift 2 ;;
+            --device-warmup )
+                DEVICE_WARMUP=$2
+                shift 2 ;;
+            --device-warmup-dataset-path )
+                WARMUP_DATASET_PATH=$2
+                shift 2 ;;
+            --device-warmup-iterations )
+                WARMUP_ITERATIONS=$2
+                shift 2 ;;
+            -- )
+                shift
+                break ;;
+            * )
+                if [[ -n "$1" ]]; then
+                    echo "error: invalid parameter: $1"
+                    exit -1
+                fi
+                break ;;
+        esac
+    done
+
+}
+
+function generate_hostsfile()
+{
+    HOSTS_PATH=$1
+    HOSTSFILE_PATH=$2
+    local num_nodes=${3:-8}
+
+    rm -rf $HOSTSFILE_PATH
+    touch $HOSTSFILE_PATH
+
+    while IFS= read -r ip; do
+        echo "$ip slots=$num_nodes" >> $HOSTSFILE_PATH
+    done < "$HOSTS_PATH"
+
+    echo "hostsfile: "
+    cat $HOSTSFILE_PATH
+}
+
+
+# Default values for arguments, that can be overridden from cmd by parse_args func or env variable
+DATA_DIR="/mnt/weka/data/mlperf_datasets/gpt-3/c4_mlperf_19_12_2022/preprocessed_c4_spm"
+NUM_NODES=8
+DEVICES_PER_NODE=8
+DP=1
+TP=8
+PP=8
+NUM_LAYERS=96
+HIDDEN_SIZE=12288
+NUM_ATTENTION_HEADS=96
+SEQ_LENGTH=2048
+DROPOUT=0.0
+MICRO_BATCH=2
+EVAL_MICRO_BATCH=8
+GLOBAL_BATCH=2048
+CLIP_GRAD=1.0
+ZERO_STAGE=0
+TRAIN_SAMPLES=84500000
+LR=2.0e-5
+MIN_LR=2.0e-6
+LR_DECAY_SAMPLES=166809600
+LR_WARMUP_SAMPLES=407040
+SEED=${RANDOM}
+EVAL_ITERS=-1
+EVAL_INTERVAL=12
+EXIT_INTERVAL=500
+START_FROM_CKPT=true
+SAVE_CKPT=true
+SAVE_INTERVAL=500
+LOG_INTERVAL=1
+UNIVERSAL_CKPT_PATH="/mnt/weka/data/pytorch/gpt3/gpt3_spmd1x64x24_tpuv4-3072_v84_20221101_universal4000"
+OUTPUT_DIR=${OUTPUT_DIR:-"/tmp"}
+HOSTS=""
+HOSTSFILE="/root/shared/hostsfile"
+MLLOG_FILE="/tmp/result_0.txt"
+EVAL_LOSS_EXIT_VALUE=2.69
+TRANSFORMER_ENGINE_FLAG=""
+USE_FUSED_SDPA="--use-fused-sdpa true"
+USE_FUSED_SDPA_WITH_RECOMPUTE_ARG="false"
+FP8_MEASURE_INTERVAL=16
+CACHE_FP8_WEIGHT_FWD_FLAG="--cache-fp8-weight-fwd true"
+HPU_GRAPHS_FLAG="--use-hpu-graphs false"
+ACCUMULATE_GRADS_VIA_HOOKS="true"
+EXTERNAL_TRAINING_ITERATIONS=4000
+EXTERNAL_GBS=1536
+SEQUENCE_PARALLEL=true
+DEVICE_WARMUP=true
+WARMUP_DATASET_PATH="/mnt/weka/data/mlperf_datasets/gpt-3/synthetic_dataset/warmup_dataset"
+WARMUP_ITERATIONS=5
+CACHE_FP8_WEIGHT_FLAG="--cache-fp8-weight"
+
+parse_args "$@"
+
+if [ -f "$HOSTS" ]; then
+    generate_hostsfile $HOSTS $HOSTSFILE 8
+fi
+
+# data and model dir paths
+DATA_PATH_6=$DATA_DIR/c4_en_6_c4_spm_text_document
+DATA_PATH_7=$DATA_DIR/c4_en_7_c4_spm_text_document
+VALID_DATA_PATH=$DATA_DIR/c4_en_validation_c4_spm_text_document
+MODEL_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+# allow to override /proc file system in case it is mounted with different name on docker container
+PROC_FS=${PROC_FS:-"/proc"}
+
+# output log path
+if [ -z "$OUTPUT_DIR" ]; then
+  RUNTIME=`date +"%Y%m%d_%H%M"`
+  OUTPUT_DIR=out/gpt3/ds_z${ZERO_STAGE}_nl${NUM_LAYERS}_hs${HIDDEN_SIZE}_gb${GLOBAL_BATCH}_mb${MICRO_BATCH}_D${DP}_T${TP}_P${PP}_${RUNTIME}
+fi
+if [ -z "$TENSORBOARD_DIR" ]; then
+    TENSORBOARD_DIR=$OUTPUT_DIR/tensorboard
+fi
+
+# saving checkpoint args
+if [ $SAVE_CKPT = true ] || [ $SAVE_CKPT = 1 ]; then
+    if [ -z "$SAVE_CKPT_DIR" ]; then
+        SAVE_CKPT_DIR=$OUTPUT_DIR/checkpoints
+    fi
+    SAVE_CKPT_ARGS=" --save $SAVE_CKPT_DIR --save-interval $SAVE_INTERVAL "
+fi
+
+if [ "$DEVICE_WARMUP" == "true" ]; then
+    DEVICE_WARMUP_ARG=" --device-warmup --warmup-dataset-path $WARMUP_DATASET_PATH --device-warmup-iterations $WARMUP_ITERATIONS"
+fi
+
+# handle kill switch argument
+if [ -n "$KILL_SWITCH_FILE" ]; then
+    KILL_SWITCH_ARG="--kill-switch-path $KILL_SWITCH_FILE"
+fi
+
+# Checkpoint loading configure
+LOAD_CHECKPOINT_ARGS=""
+if [ $START_FROM_CKPT = true ] || [ $START_FROM_CKPT = 1 ]; then
+    CHECKPOINTS_BACKUP="$OUTPUT_DIR/../../checkpoints"
+    if [ "$(ls -A $CHECKPOINTS_BACKUP 2>/dev/null)" ]; then
+        LOAD_CHECKPOINT_ARGS=" --load $CHECKPOINTS_BACKUP "
+    else
+        LOAD_CHECKPOINT_ARGS=" --load $UNIVERSAL_CKPT_PATH --universal-checkpoint --no-load-rng "
+    fi
+fi
+
+# Sequence parallelism
+SEQUENCE_PARALLEL_ARG="--sequence-parallel"
+PARTITIONED_MODE="false"
+if [ $SEQUENCE_PARALLEL = false ]; then
+    SEQUENCE_PARALLEL_ARG=""
+    PARTITIONED_MODE="true"
+fi
+
+# Activation checkpointing or recompute
+if [[ $USE_FUSED_SDPA_WITH_RECOMPUTE_ARG == "false" ]]; then
+    ACTIVATION_CHECKPOINTING="--checkpoint-activations \
+                              --checkpoint-activations-granularity=selective "
+else
+    ACTIVATION_CHECKPOINTING=""
+fi
+
+mkdir -p ${OUTPUT_DIR}
+# create DS config
+DS_CONFIG=${OUTPUT_DIR}/ds_config.json
+cat << EOT > $DS_CONFIG
+{
+  "train_batch_size" : $GLOBAL_BATCH,
+  "train_micro_batch_size_per_gpu": $MICRO_BATCH,
+  "steps_per_print": $LOG_INTERVAL,
+
+  "zero_optimization": {
+    "stage": $ZERO_STAGE
+  },
+  "gradient_clipping": $CLIP_GRAD,
+  "bf16": {
+    "enabled": true,
+    "accumulate_grads_via_hooks": $ACCUMULATE_GRADS_VIA_HOOKS
+    },
+
+  "wall_clock_breakdown" : false,
+
+  "pipeline": {
+    "pipe_partitioned": $PARTITIONED_MODE,
+    "grad_partitioned": $PARTITIONED_MODE
+  }
+}
+EOT
+
+echo "*******************************************************"
+echo "Deepspeed config:"
+cat $DS_CONFIG
+echo "*******************************************************"
+
+# DeepSpeed args
+ds_args=""
+ds_args=" --deepspeed ${ds_args}"
+ds_args=" --deepspeed_config=$DS_CONFIG ${ds_args}"
+ds_args=" --zero-stage=$ZERO_STAGE ${ds_args}"
+ds_args=" --deepspeed-activation-checkpointing ${ds_args}"
+
+CMD="sync && \
+    if [ \"\$LOCAL_RANK\" -eq \"0\" ]; then echo 3 > $PROC_FS/sys/vm/drop_caches ; fi && \
+    python -u $MODEL_DIR/pretrain_gpt.py \
+    --use_hpu \
+    --distributed-backend=hccl \
+    --tensor-model-parallel-size $TP \
+    --pipeline-model-parallel-size $PP \
+    --optimizer fusedadamw \
+    --num-layers $NUM_LAYERS \
+    --hidden-size $HIDDEN_SIZE \
+    --num-attention-heads $NUM_ATTENTION_HEADS \
+    --seq-length $SEQ_LENGTH \
+    --loss-scale 1 \
+    --max-position-embeddings $SEQ_LENGTH \
+    --micro-batch-size $MICRO_BATCH \
+    --eval-micro-batch-size $EVAL_MICRO_BATCH \
+    --global-batch-size $GLOBAL_BATCH \
+    --lr $LR \
+    --min-lr $MIN_LR \
+    --lr-decay-style cosine \
+    --train-samples $TRAIN_SAMPLES \
+    --lr-decay-samples $LR_DECAY_SAMPLES \
+    --lr-warmup-samples $LR_WARMUP_SAMPLES \
+    --log-interval $LOG_INTERVAL \
+    --train-data-path 0.5 $DATA_PATH_6 0.5 $DATA_PATH_7 \
+    --valid-data-path 1.0 $VALID_DATA_PATH \
+    --eval-iters $EVAL_ITERS \
+    --eval-interval $EVAL_INTERVAL \
+    --vocab-file $DATA_DIR/vocab.json \
+    --merge-file $DATA_DIR/merges.txt \
+    --split 100,0,0 \
+    --clip-grad $CLIP_GRAD \
+    --attention-dropout $DROPOUT \
+    --hidden-dropout $DROPOUT \
+    --no-query-key-layer-scaling \
+    --adam-beta1 0.9 \
+    --adam-beta2 0.95 \
+    --weight-decay 0.1 \
+    --init-method-std 0.006 \
+    --seed $SEED \
+    --bf16 \
+    $ACTIVATION_CHECKPOINTING \
+    --tensorboard-dir $TENSORBOARD_DIR \
+    --log-validation-ppl-to-tensorboard \
+    --no-bias-gelu-fusion \
+    --no-masked-softmax-fusion \
+    --no-bias-dropout-fusion \
+    --mask-tensor-adding \
+    --fix-position-emb-redundant-alloc \
+    --no-scaled-init \
+    --no-seq-len-plus-one-tokens \
+    --apply-layernorm-weight-plus-one \
+    --do-layernorm-bias-weight-decay \
+    --exit-interval $EXIT_INTERVAL \
+    --DDP-impl local  \
+    --mllog-output-path $MLLOG_FILE \
+    --eval-loss-exit-value $EVAL_LOSS_EXIT_VALUE \
+    --ext-lr-steps $(($EXTERNAL_TRAINING_ITERATIONS*$EXTERNAL_GBS)) \
+    $LOAD_CHECKPOINT_ARGS \
+    $SAVE_CKPT_ARGS \
+    $KILL_SWITCH_ARG \
+    $TRANSFORMER_ENGINE_FLAG \
+    $USE_FUSED_SDPA \
+    $DEVICE_WARMUP_ARG \
+    --hpu-fp8-measure-interval $FP8_MEASURE_INTERVAL \
+    $CACHE_FP8_WEIGHT_FWD_FLAG \
+    $HPU_GRAPHS_FLAG \
+    $CACHE_FP8_WEIGHT_FLAG \
+    $PROFILE_FLAG \
+    $PROFILE_STEPS_FLAG \
+    $SEQUENCE_PARALLEL_ARG \
+    $ds_args"
+
+
+# configure multinode
+if [ "$NUM_NODES" -ne "1" -a -f "$HOSTSFILE" ]
+then
+    MULTINODE_CMD="--force_multi \
+                    --hostfile=$HOSTSFILE \
+                    --master_addr $(head -n 1 $HOSTSFILE | sed -n s/[[:space:]]slots.*//p) "
+fi
+
+# run gpt3
+deepspeed --num_nodes ${NUM_NODES} \
+          --num_gpus ${DEVICES_PER_NODE} \
+          --no_local_rank \
+          --no_python \
+          $MULTINODE_CMD \
+          /usr/bin/bash -c "$CMD"

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/setup.py

@@ -0,0 +1,91 @@
+# coding=utf-8
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Setup for pip package."""
+
+import os
+import sys
+import setuptools
+
+if sys.version_info < (3,):
+    raise Exception("Python 2 is not supported by Megatron.")
+
+from megatron.package_info import (
+    __description__,
+    __contact_names__,
+    __url__,
+    __download_url__,
+    __keywords__,
+    __license__,
+    __package_name__,
+    __version__,
+)
+
+with open("README.md", "r") as fh:
+    long_description = fh.read()
+
+###############################################################################
+#                             Dependency Loading                              #
+# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% #
+
+
+def req_file(filename):
+    with open(filename) as f:
+        content = f.readlines()
+    return [x.strip() for x in content]
+
+
+install_requires = req_file("requirements.txt")
+
+setuptools.setup(
+    name=__package_name__,
+    # Versions should comply with PEP440.  For a discussion on single-sourcing
+    # the version across setup.py and the project code, see
+    # https://packaging.python.org/en/latest/single_source_version.html
+    version=__version__,
+    description=__description__,
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    # The project's main homepage.
+    url=__url__,
+    author=__contact_names__,
+    maintainer=__contact_names__,
+    # The licence under which the project is released
+    license=__license__,
+    classifiers=[
+        'Intended Audience :: Developers',
+        'Intended Audience :: Science/Research',
+        'Intended Audience :: Information Technology',
+        # Indicate what your project relates to
+        'Topic :: Scientific/Engineering :: Artificial Intelligence',
+        'Topic :: Software Development :: Libraries :: Python Modules',
+        # Supported python versions
+        'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+        # Additional Setting
+        'Environment :: Console',
+        'Natural Language :: English',
+        'Operating System :: OS Independent',
+    ],
+    python_requires='>=3.6',
+    packages=setuptools.find_packages(),
+    install_requires=install_requires,
+    # Add in any packaged data.
+    include_package_data=True,
+    zip_safe=False,
+    # PyPI package information.
+    keywords=__keywords__
+)

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/tools/convert_checkpoint/convert_paxml_optimizer.py

@@ -0,0 +1,426 @@
+# Copyright (c) 2021-2022, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+###############################################################################
+# Copyright (C) 2023 Habana Labs, Ltd. an Intel Company
+###############################################################################
+"""Script to load layer(s) of the LLM checkpoint using TensorStore.
+More details about TensorStore, please visit 
+https://github.com/google/tensorstore .
+"""
+
+import argparse
+import tensorstore as ts
+import glob
+import json
+import torch
+import os
+import sys
+import multiprocessing
+from datetime import datetime
+
+def get_numpy_array(filename):
+    spec = {'driver': 'zarr', 'metadata_key': '.zarray', 'kvstore': {}}
+    spec['kvstore'] = {
+        'driver': 'file',
+        'path': filename,
+    }
+
+    t = ts.open(ts.Spec(spec), open=True).result()
+    t_v = t.read().result()
+    return t_v
+
+def get_torch_tensor(filename, dtype):
+    array = get_numpy_array(filename)
+    array_torch = torch.from_numpy(array)
+    array_torch = array_torch.to(dtype)
+    return array_torch
+
+def get_layer_info(output_dir, lyr_num, nv_name):
+    lyr_dir = os.path.join(output_dir, F"layer_{str(lyr_num)}")
+    lyr_name = "language_model.encoder.layers."+str(lyr_num)+"."+nv_name
+    return lyr_dir, lyr_name
+
+def store_tensor(save_tensor, lyr_dir, lyr_name, params_dict):
+    optim_state = {}
+    optim_state["state"] = {}
+    optim_state["state"]["exp_avg"] = save_tensor["m"]
+    optim_state["state"]["exp_avg_sq"] = save_tensor["v"]
+    optim_state["fp32_from_fp16_params"] = save_tensor["w"]
+    if params_dict is not None:
+        optim_state["param_groups"] = params_dict
+    torch.save(optim_state, os.path.join(lyr_dir, lyr_name + ".pt"))
+
+def copy_layers(args, nv_name, g_name, prefix, params_dict):
+
+    array_torch = {}
+    g_name_path = os.path.join(args.google_ckpts, prefix + ".m." + g_name)
+    array_torch["m"] = get_torch_tensor(g_name_path, args.dtype)
+    g_name_path = os.path.join(args.google_ckpts, prefix + ".v." + g_name)
+    array_torch["v"] = get_torch_tensor(g_name_path, args.dtype)
+    g_name_path = os.path.join(args.google_ckpts, "mdl_vars." + g_name)
+    array_torch["w"] = get_torch_tensor(g_name_path, args.dtype)
+
+    print(F"G Name: {g_name}, shape: {array_torch['m'].shape}", flush=True)
+    save_tensor = {}
+    if nv_name == "language_model.embedding.position_embeddings.weight":
+        start_idx = 0
+        end_idx = 2048
+        for key in list(array_torch.keys()):
+            save_tensor[key] = array_torch[key][start_idx: end_idx, :].contiguous().detach().clone()
+        print(F"NV Name: {nv_name}, shape: {save_tensor['m'].shape}", flush=True)
+        store_tensor(save_tensor, args.output_dir, nv_name, params_dict)
+    elif nv_name == "language_model.embedding.word_embeddings.weight":
+        for key in list(array_torch.keys()):
+            save_tensor[key] = array_torch[key].transpose(0, 1).contiguous().detach().clone()
+        print(F"NV Name: {nv_name}, shape: {save_tensor['m'].shape}", flush=True)
+        store_tensor(save_tensor, args.output_dir, nv_name, params_dict)
+        store_tensor(save_tensor, args.output_dir, "word_embeddings.weight", params_dict)
+    else:
+        for key in list(array_torch.keys()):
+            save_tensor[key] = array_torch[key].detach().clone()
+        print(F"NV Name: {nv_name}, shape: {save_tensor['m'].shape}", flush=True)
+        store_tensor(save_tensor, args.output_dir, nv_name, params_dict)
+    del save_tensor
+    del array_torch
+
+def split_encoder_layers(args, nv_name, g_name, prefix, params_dict):
+    array_torch = {}
+    g_name_path = os.path.join(args.google_ckpts, prefix + ".m." + g_name)
+    array_torch["m"] = get_torch_tensor(g_name_path, args.dtype)
+    g_name_path = os.path.join(args.google_ckpts, prefix + ".v." + g_name)
+    array_torch["v"] = get_torch_tensor(g_name_path, args.dtype)
+    g_name_path = os.path.join(args.google_ckpts, "mdl_vars." + g_name)
+    array_torch["w"] = get_torch_tensor(g_name_path, args.dtype)
+    print(F"G Name: {g_name}, shape: {array_torch['m'].shape}", flush=True)
+    save_tensor = {}
+    if (
+        nv_name == "mlp.dense_4h_to_h.bias" 
+        or nv_name == "post_attention_layernorm.bias" 
+        or nv_name == "post_attention_layernorm.weight" 
+        or nv_name == "input_layernorm.bias" 
+        or nv_name == "input_layernorm.weight" 
+        or nv_name == "self_attention.dense.bias" 
+        or nv_name == "mlp.dense_h_to_4h.bias" 
+        or nv_name == "self_attention.dense.weight"
+    ):
+        print(F"1st Check: {nv_name}")    
+        for lyr_num in range(args.num_layers):
+            print("layer_num=",lyr_num)
+            lyr_dir, lyr_name = get_layer_info(args.output_dir, lyr_num, nv_name)
+            for key in list(array_torch.keys()):
+                save_tensor[key] = array_torch[key][lyr_num].contiguous().detach().clone()
+            if lyr_num == (args.num_layers // 2):
+                print(F"NV Name: {nv_name}, shape: {save_tensor['m'].shape}", flush=True)
+            store_tensor(save_tensor, lyr_dir, lyr_name, params_dict)
+            save_tensor = {}
+
+    elif (
+        nv_name == "mlp.dense_h_to_4h.weight" 
+        or nv_name == "mlp.dense_4h_to_h.weight"
+    ):
+        print(F"2nd Check: {nv_name}")
+        for lyr_num in range(args.num_layers):
+            print("layer_num=",lyr_num)
+            lyr_dir, lyr_name = get_layer_info(args.output_dir, lyr_num, nv_name)
+            for key in list(array_torch.keys()):
+                save_tensor[key] = array_torch[key][lyr_num].transpose(0, 1).contiguous().detach().clone()
+                #save_tensor = save_tensor.transpose(0, 1).clone()
+            if lyr_num == (args.num_layers // 2):
+                print(F"NV Name: {nv_name}, shape: {save_tensor['v'].shape}", flush=True)
+            store_tensor(save_tensor, lyr_dir, lyr_name, params_dict)
+            save_tensor = {}
+    elif nv_name == "self_attention.query_key_value.weight":
+        print(F"3nd Check: {nv_name}")
+        # nv shape [4608, 12288] => 4608 = 12 (heads) * 3 (qkv) * 128 (hidden_size / heads)
+        # google shape [96, 3, 12288, 96, 128]
+        for lyr_num in range(args.num_layers):
+            print("layer_num=",lyr_num)
+            lyr_dir, lyr_name = get_layer_info(args.output_dir, lyr_num, nv_name)
+            for key in list(array_torch.keys()):
+                save_tensor[key] = array_torch[key][lyr_num].permute(2, 0, 3, 1).contiguous().detach().clone()
+                #save_tensor = save_tensor.permute(2, 0, 3, 1).contiguous().clone()
+            if lyr_num == (args.num_layers // 2):
+                print(F"NV Name: {nv_name}, shape: {save_tensor['w'].shape}", flush=True)
+            store_tensor(save_tensor, lyr_dir, lyr_name, params_dict)
+            save_tensor = {}
+    elif nv_name == "self_attention.query_key_value.bias":
+        print(F"4rd Check: {nv_name}")
+        # nv shape [4608] => 4608 = 12 (heads) * 3 (qkv) * 128 (hidden_size / heads)
+        # google shape [96, 3, 96, 128]
+        for lyr_num in range(args.num_layers):
+            print("layer_num=",lyr_num)
+            lyr_dir, lyr_name = get_layer_info(args.output_dir, lyr_num, nv_name)
+            for key in list(array_torch.keys()):
+                save_tensor[key] = array_torch[key][lyr_num].permute(1, 0, 2).contiguous().detach().clone()
+                #save_tensor = save_tensor.permute(1, 0, 2).contiguous().clone()
+            if lyr_num == (args.num_layers // 2):
+                print(F"NV Name: {nv_name}, shape: {save_tensor['m'].shape}", flush=True)
+            store_tensor(save_tensor, lyr_dir, lyr_name, params_dict)
+            save_tensor = {}
+    else:
+        print(F"Not a valid layer name: {nv_name}", flush=True)
+        sys.exit()
+    del array_torch
+
+
+def arrange_google_ckpts(args, prefix1, prefix2):
+
+    output_dir = args.output_dir
+    num_layers = args.num_layers
+    
+    params_dict = None
+    if args.params_file is not None:
+        with open(args.params_file, 'r') as f: 
+            params_dict = json.load(f)
+    else:
+        print(F"For Megatron-LM Optimizer to get the right optimizer params, provide params_file json", flush=True)
+
+    if args.dtype == "bf16":
+        args.dtype = torch.bfloat16
+    else:
+        args.dtype = torch.float
+
+    for lyr_num in range(num_layers):
+        pp_id_dir = os.path.join(output_dir, f"layer_{str(lyr_num)}")
+        os.makedirs(pp_id_dir, exist_ok=True)
+    
+    #layers that are not part of encoder blocks.
+    torch.multiprocessing.set_start_method("spawn")
+    torch.multiprocessing.set_sharing_strategy("file_system")
+
+
+    nv_g_names_pairs = [
+            ("language_model.embedding.word_embeddings.weight", "params.lm.softmax.logits_ffn.linear.w"),
+            ("language_model.embedding.position_embeddings.weight", "params.lm.position_emb.emb_var"),
+            ("language_model.encoder.final_layernorm.weight", "params.lm.final_ln.scale"),
+            ("language_model.encoder.final_layernorm.bias", "params.lm.final_ln.bias"),
+        ]
+    pool = multiprocessing.Pool(args.pool)
+    pool.starmap(
+            copy_layers,
+            [
+                (
+                    args,
+                    nv_name,
+                    g_name,
+                    prefix1,
+                    params_dict,
+                )
+                for (nv_name, g_name) in nv_g_names_pairs
+            ],
+        )
+    pool.close()
+    pool.join()
+
+
+
+    nv_g_names_pairs1 = [
+        ("mlp.dense_4h_to_h.bias", "params.lm.transformer.repeat.sub.x_layers_0.ff_layer.ffn_layer2.bias.b"),
+    ]
+
+    pool = multiprocessing.Pool(args.pool)
+    pool.starmap(
+            split_encoder_layers,
+            [
+                (
+                    args,
+                    nv_name,
+                    g_name,
+                    prefix2,
+                    params_dict,
+                )
+                for (nv_name, g_name) in nv_g_names_pairs1
+            ],
+        )
+    pool.close()
+    pool.join()
+
+    nv_g_names_pairs2 = [
+        ("post_attention_layernorm.bias", "params.lm.transformer.repeat.sub.x_layers_0.ff_layer.layer_norm.bias"),
+        ("post_attention_layernorm.weight", "params.lm.transformer.repeat.sub.x_layers_0.ff_layer.layer_norm.scale"),
+        ("input_layernorm.bias", "params.lm.transformer.repeat.sub.x_layers_0.layer_norm.bias"),
+        ("input_layernorm.weight", "params.lm.transformer.repeat.sub.x_layers_0.layer_norm.scale"),
+        ("self_attention.dense.bias", "params.lm.transformer.repeat.sub.x_layers_0.self_attention.post.b"),
+    ]
+
+    pool = multiprocessing.Pool(args.pool)
+    pool.starmap(
+            split_encoder_layers,
+            [
+                (
+                    args,
+                    nv_name,
+                    g_name,
+                    prefix2,
+                    params_dict,
+                )
+                for (nv_name, g_name) in nv_g_names_pairs2
+            ],
+        )
+    pool.close()
+    pool.join()
+
+    nv_g_names_pairs3 = [
+        ("mlp.dense_h_to_4h.bias", "params.lm.transformer.repeat.sub.x_layers_0.ff_layer.ffn_layer1.bias.b"),
+    ]
+
+    pool = multiprocessing.Pool(args.pool)
+    pool.starmap(
+        split_encoder_layers,
+        [
+            (
+                args,
+                nv_name,
+                g_name,
+                prefix2,
+                params_dict,
+            )
+            for (nv_name, g_name) in nv_g_names_pairs3
+        ],
+    )
+    pool.close()
+    pool.join()
+
+    nv_g_names_pairs4 = [
+        ("mlp.dense_h_to_4h.weight", "params.lm.transformer.repeat.sub.x_layers_0.ff_layer.ffn_layer1.linear.w"),
+    ]
+
+    pool = multiprocessing.Pool(args.pool)
+    pool.starmap(
+        split_encoder_layers,
+        [
+            (
+                args,
+                nv_name,
+                g_name,
+                prefix2,
+                params_dict,
+            )
+            for (nv_name, g_name) in nv_g_names_pairs4
+        ],
+    )
+    pool.close()
+    pool.join()
+
+    nv_g_names_pairs5 = [
+        ("mlp.dense_4h_to_h.weight", "params.lm.transformer.repeat.sub.x_layers_0.ff_layer.ffn_layer2.linear.w"),
+        ("self_attention.dense.weight", "params.lm.transformer.repeat.sub.x_layers_0.self_attention.post.w"),
+        ("self_attention.query_key_value.weight",
+         "params.lm.transformer.repeat.sub.x_layers_0.self_attention.combined_qkv.w"),
+        ("self_attention.query_key_value.bias",
+         "params.lm.transformer.repeat.sub.x_layers_0.self_attention.combined_qkv.b"),
+    ]
+
+    pool = multiprocessing.Pool(args.pool)
+    pool.starmap(
+        split_encoder_layers,
+        [
+            (
+                args,
+                nv_name,
+                g_name,
+                prefix2,
+                params_dict,
+            )
+            for (nv_name, g_name) in nv_g_names_pairs5
+        ],
+    )
+    pool.close()
+    pool.join()
+
+    exit(0)
+
+    nv_g_names_pairs = [
+        ("mlp.dense_4h_to_h.bias", "params.lm.transformer.repeat.sub.x_layers_0.ff_layer.ffn_layer2.bias.b"),
+        ("post_attention_layernorm.bias", "params.lm.transformer.repeat.sub.x_layers_0.ff_layer.layer_norm.bias"),
+        ("post_attention_layernorm.weight", "params.lm.transformer.repeat.sub.x_layers_0.ff_layer.layer_norm.scale"),
+        ("input_layernorm.bias", "params.lm.transformer.repeat.sub.x_layers_0.layer_norm.bias"),
+        ("input_layernorm.weight", "params.lm.transformer.repeat.sub.x_layers_0.layer_norm.scale"),
+        ("self_attention.dense.bias", "params.lm.transformer.repeat.sub.x_layers_0.self_attention.post.b"),
+        ("mlp.dense_h_to_4h.bias", "params.lm.transformer.repeat.sub.x_layers_0.ff_layer.ffn_layer1.bias.b"),
+        ("mlp.dense_h_to_4h.weight", "params.lm.transformer.repeat.sub.x_layers_0.ff_layer.ffn_layer1.linear.w"),
+        ("mlp.dense_4h_to_h.weight", "params.lm.transformer.repeat.sub.x_layers_0.ff_layer.ffn_layer2.linear.w"),
+        ("self_attention.dense.weight", "params.lm.transformer.repeat.sub.x_layers_0.self_attention.post.w"),
+        ("self_attention.query_key_value.weight",
+         "params.lm.transformer.repeat.sub.x_layers_0.self_attention.combined_qkv.w"),
+        ("self_attention.query_key_value.bias",
+         "params.lm.transformer.repeat.sub.x_layers_0.self_attention.combined_qkv.b"),
+    ]
+
+    pool = multiprocessing.Pool(args.pool)
+    pool.starmap(
+            split_encoder_layers,
+            [
+                (
+                    args,
+                    nv_name,
+                    g_name,
+                    prefix2,
+                    params_dict,
+                )
+                for (nv_name, g_name) in nv_g_names_pairs
+            ],
+        )
+    pool.close()
+    pool.join()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(formatter_class=argparse.RawTextHelpFormatter)
+    parser.add_argument(
+        '--google_ckpts', "-gckpt",
+        type=str,
+        default='/workspace/data/checkpoint_00001300',
+        help='Google Checkpoint directory')
+    parser.add_argument(
+        '--output_dir', "-o",
+        type=str,
+        default='google_to_torch_output',
+        help='Output directory')
+    parser.add_argument(
+        '--dtype', "-dt",
+        type=str,
+        default="float",
+        help='datatype')
+    parser.add_argument(
+        '--num_layers', "-nl",
+        type=int,
+        default=96,
+        help='number of encoder layers')
+    parser.add_argument(
+        '--params_file', "-pl",
+        type=str,
+        default=None,
+        help='Json File for Param Groups')
+    parser.add_argument(
+        '--pool', "-p",
+        type=int,
+        default=4,
+        help='parallel processes')
+
+    args = parser.parse_args()
+    print("\n=============== Argument ===============")
+    for key in vars(args):
+        print(f"{key}: {vars(args)[key]}")
+    print("========================================")
+
+    param1 = "opt_states_0.no_prefix_2"        #Assij
+    param2 = "opt_states_0.p#96#i-1_2"
+
+
+    start_time = datetime.now()
+    arrange_google_ckpts(args, param1, param2)
+    stop_time = datetime.now()
+    run_time = stop_time - start_time
+    print(f"[INFO] Spend {run_time} (h:m:s) to convert the model")

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/tools/convert_checkpoint/deepspeed_checkpoint.py

@@ -0,0 +1,196 @@
+import os
+from typing import Dict
+import torch 
+
+ZERO_FILE_PREFIX = 'zero_pp_rank_'
+LAYER_FILE_PREFIX = 'layer_'
+MP_RANK_FILE_PREFIX = 'mp_rank_'
+EMBEDDING_LAYER_INDEX = 0
+FINAL_LAYER_NORM_INDEX = -1
+ARGS_KEY = 'args'
+ITERATION_KEY = 'iteration'
+SEQUENTIAL_LAYERS = [
+    'input_layernorm.weight', 'input_layernorm.bias',
+    'self_attention.dense.bias',
+    'post_attention_layernorm.weight', 'post_attention_layernorm.bias',
+    'mlp.dense_4h_to_h.bias',
+    'position_embeddings.weight'
+]
+
+LAYER_CONCAT_DIM = {
+    'self_attention.dense.weight': 1,
+    'mlp.dense_4h_to_h.weight': 1
+}
+
+class DeepSpeedCheckpoint(object):
+    def __init__(self, dir, tp_degree=None, pp_degree=None, no_pp=False):
+        self.dir = dir
+        self.no_pp = no_pp
+        self.file_list = self._get_files(dir)
+        self.zero_files = self._get_files_with_prefix(self.file_list, ZERO_FILE_PREFIX)
+        self.layer_files = self._get_files_with_prefix(self.file_list, LAYER_FILE_PREFIX)
+        self.mp_rank_files = self._get_files_with_prefix(self.file_list, MP_RANK_FILE_PREFIX)
+        self.layer_keys = self._get_layer_keys()
+        self.layer_count = len(self.layer_keys)
+        if not self.no_pp:
+            self.original_tp_degree = len(self._get_files_with_prefix(self.layer_files, f'{LAYER_FILE_PREFIX}01'))
+            self.original_pp_degree = len(self.mp_rank_files) // self.original_tp_degree
+        else:
+            self.original_tp_degree = len(self.mp_rank_files)
+            self.original_pp_degree = 1
+        self.dp_degree = len(self.zero_files) // (self.original_pp_degree * self.original_tp_degree)
+        self.tp_degree = self.original_tp_degree if tp_degree is None else tp_degree
+        self.pp_degree = self.original_pp_degree if pp_degree is None else pp_degree
+        self.global_state = {}
+    
+        self._sanity_check()
+        self.pp_to_transformer_map = self._build_pp_transformer_map()
+        self.transformer_file_map = self._build_transformer_file_map()
+        if not self.no_pp:
+            self.tp_to_embedding_map = self._build_tp_other_layer_map(EMBEDDING_LAYER_INDEX)
+            self.tp_to_final_norm_map = self._build_tp_other_layer_map(FINAL_LAYER_NORM_INDEX)
+        self._build_global_state()
+
+
+
+    def show_tp_embedding_map(self):
+        self._dump_mapping(self.tp_to_embedding_map, 'tp_to_embedding_layers')
+
+    def show_tp_final_norm_map(self):
+        self._dump_mapping(self.tp_to_final_norm_map, 'tp_to_final_norm_layers')
+
+    def show_pp_tranformer_map(self):
+        self._dump_mapping(self.pp_to_transformer_map, 'pp_to_tranformer_layers')
+
+    def show_transformer_file_map(self):
+        self._dump_mapping(self.transformer_file_map, 'rank_to_tranformer_files')
+
+    def _build_global_state(self):
+        sd = torch.load(self.mp_rank_files[0], map_location=torch.device('cpu'))
+        self.global_state[ITERATION_KEY] = sd.get(ITERATION_KEY, 0)
+        self.global_state[ARGS_KEY] = sd.get(ARGS_KEY, None)
+
+    def get_iteration(self):
+        if not ITERATION_KEY in self.global_state:
+            sd = torch.load(self.mp_rank_files[0], map_location=torch.device('cpu'))
+            self.global_state[ITERATION_KEY] = sd.get(ITERATION_KEY, 0)
+
+        return self.global_state[ITERATION_KEY]
+
+    def get_embedding_state(self, tp_index: int) -> Dict:
+        assert tp_index in self.tp_to_embedding_map.keys()
+        sd_list = [torch.load(fname, map_location=torch.device('cpu')) for fname in self.tp_to_embedding_map[tp_index]]
+        sd = self._merge_state_dicts(sd_list)
+        return sd
+
+    def get_args(self):
+        if not ARGS_KEY in self.global_state:
+            sd = torch.load(self.mp_rank_files[0], map_location=torch.device('cpu'))
+            self.global_state[ARGS_KEY] = sd.get(ARGS_KEY, None)
+
+        return self.global_state[ARGS_KEY]
+    
+
+    def get_transformer_state(self, tp_index: int, pp_index: int) -> list:
+        assert tp_index < self.tp_degree
+        assert pp_index < self.pp_degree
+        t_list = []
+        for fname_list in self.transformer_file_map[(tp_index, pp_index)]:
+            sd_list = [torch.load(fname, map_location=torch.device('cpu')) for fname in fname_list]
+            sd = self._merge_state_dicts(sd_list)
+            t_list.append(sd)
+        return t_list   
+
+    def get_final_norm_state(self, tp_index:int) -> Dict:
+        assert tp_index in self.tp_to_final_norm_map.keys()
+        sd = torch.load(self.tp_to_final_norm_map[tp_index][0], map_location=torch.device('cpu'))
+        return sd
+
+    def _build_tp_other_layer_map(self, layer_index:int):
+        assert layer_index < len(self.layer_files)
+        layer_files = self._get_files_with_prefix(self.layer_files, self.layer_keys[layer_index])
+        layer_file_partitions = self._partition_data(layer_files, self.tp_degree)
+        data_map = {i:flist for i, flist in enumerate(layer_file_partitions)}
+        return data_map
+
+    def _build_pp_transformer_map(self):
+        data_map = {}
+        transformer_layers = self.layer_keys[1:-1]
+        layers_per_pp = len(transformer_layers) // self.pp_degree
+        data_map = {i:transformer_layers[i*layers_per_pp:(i+1)*layers_per_pp] for i in range(0, self.pp_degree)}
+        return data_map
+
+    def _dump_mapping(self, data_map, map_tag = None):
+        if map_tag is not None:
+            print(f'Dump mapping: {map_tag}')
+        for k, v in data_map.items():
+            print(f'{k} = {v}')
+
+    def _build_transformer_file_map(self):
+        transformer_layer_keys = self.layer_keys[1:-1]
+        file_map = {}
+        layers_per_pp = len(transformer_layer_keys) // self.pp_degree
+        for key_index, layer_key in enumerate(transformer_layer_keys):
+            pp_index = key_index // layers_per_pp
+            layer_files = self._get_files_with_prefix(self.layer_files, layer_key)
+            layer_file_partitions = self._partition_data(layer_files, self.tp_degree)
+            for tp_index in range(self.tp_degree):
+                map_key = (tp_index, pp_index)
+                if not map_key in file_map.keys():
+                    file_map[map_key] = []
+                file_map[map_key].append(layer_file_partitions[tp_index])
+        
+        return file_map
+        
+    def _sanity_check(self):
+        assert len(self.mp_rank_files) % self.tp_degree == 0
+        assert len(self.zero_files) % (self.pp_degree * self.tp_degree) == 0
+        if not self.no_pp:
+            assert len(self.layer_keys) > 2
+            assert (len(self.layer_keys) - 2) % self.pp_degree == 0
+     
+    def _get_files_with_prefix(self, all_files, prefix):
+        file_list = []
+        for file_path in all_files:
+            _, fname = os.path.split(file_path)
+            if fname.startswith(prefix):
+                file_list.append(file_path)
+        
+        return sorted(file_list)
+
+    def validate_files(self):
+        for file in self.file_list:
+            if not os.path.isfile(file):
+                print(f'Error: {file} is not existent')
+        
+    def _get_files(self, dir):
+        file_list = []
+        for root, dirs, files in os.walk(dir):
+            for file in files:
+                file_list.append(os.path.join(root, file))
+        return file_list
+
+    def _get_layer_keys(self):
+        key_set = set()
+        key_len = len(LAYER_FILE_PREFIX) + 2 
+        for file_path in self.layer_files:
+            _, fname = os.path.split(file_path)
+            key_set.add(fname[:key_len])
+        return sorted(list(key_set))
+
+    def _partition_data(self, data_list, num_partitions):
+        num_elems = len(data_list)
+        assert num_elems % num_partitions == 0
+        partition_size = num_elems // num_partitions
+        partitions_list = [data_list[i:i+partition_size] for i in range(0, num_elems, partition_size)]
+        return partitions_list
+
+    def _merge_state_dicts(self, sd_list):
+        merged_sd = {}
+        for key in sd_list[0].keys():
+            if not key in SEQUENTIAL_LAYERS:
+                cat_dim = LAYER_CONCAT_DIM.get(key, 0)
+                merged_sd[key] = torch.cat([sd[key] for sd in sd_list], dim=cat_dim)
+            else:
+                merged_sd[key] = sd_list[0][key]
+        return merged_sd

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/tools/convert_checkpoint/deepspeed_to_megatron.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python
+
+import argparse
+import os
+import torch
+from collections import OrderedDict
+from .deepspeed_checkpoint import ARGS_KEY, DeepSpeedCheckpoint
+
+MODEL_KEY = 'model'
+ARGS_KEY = 'args'
+LANGUGAGE_MODEL_KEY = 'language_model'
+EMBEDDING_KEY = 'embedding'
+ENCODER_KEY = 'encoder'
+WORD_EMBEDDINGS_FOR_HEAD_KEY = 'word_embeddings_for_head'
+WORD_EMBEDDINGS_KEY = 'word_embeddings'
+FINAL_LAYER_NORM_KEY ='final_layernorm'
+CHECKPOINT_VERSION_KEY = 'checkpoint_version'
+CHECKPOINT_VERSION_VALUE = 3.0
+ITERATION_KEY = 'iteration'
+
+def parse_arguments():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--input_folder', default=None, type=str, help='Input DeepSpeed Checkpoint folder')
+    parser.add_argument('--output_folder', default=None, type=str, help='Output Megatron checkpoint folder')
+    parser.add_argument('--target_tp', default=1, type=int, help='Target TP degree')
+    parser.add_argument('--target_pp', default=1, type=int, help='Target PP degree')
+    parser.add_argument('--for_release', action='store_true', help='Convert for release purpose, reset some (progress) counters.')
+    args = parser.parse_args()
+    print(f'args = {args}')
+    return args
+
+
+def _convert_ds_transformer_state(sd_list):
+    new_sd = OrderedDict()
+    for i, sd in enumerate(sd_list):
+        for key, value in sd.items():
+            new_key = f'layers.{i}.{key}'
+            new_sd[new_key] = value
+
+    return new_sd
+
+def _create_checkpoint_paths(base_folder, iteration, tp_degree, pp_degree):
+    path_list = []
+    iter_folder = f'iter_{iteration:07d}'
+    for i in range(0, tp_degree):
+        path_list.append([])
+        for j in range(0, pp_degree):
+            rank_folder = f'mp_rank_{i:02d}' if pp_degree == 1 else f'mp_rank_{i:02d}_{j:03d}'
+            ckpt_path = os.path.join(rank_folder, 'model_optim_rng.pt')
+            path_list[i].append(os.path.join(base_folder, iter_folder, ckpt_path))
+
+    return path_list
+
+
+def _create_megatron_dict():
+    language_model_dict = {
+        EMBEDDING_KEY: {},
+        ENCODER_KEY: {}
+    }
+    megatron_dict = {
+        MODEL_KEY: {LANGUGAGE_MODEL_KEY: language_model_dict},
+        CHECKPOINT_VERSION_KEY: CHECKPOINT_VERSION_VALUE
+    }
+    return megatron_dict
+
+
+def _save_checkpoint(file_path, chkpt_sd):
+    dir, _ = os.path.split(file_path)
+    os.makedirs(dir, exist_ok=True)
+    torch.save(chkpt_sd, file_path)
+
+
+def _renest_sd(sd):
+    new_sd = OrderedDict()
+    for key, value in sd.items():
+        a, b = key.split('.')
+        new_sd[a] = {b: value}
+    return new_sd
+
+
+def _create_rank_checkpoint(ds_checkpoint, checkpoint_path, tp_index, pp_index, for_release=False):
+    meg_encoder_sd = OrderedDict()
+    meg_embedding_sd = OrderedDict()
+    meg_embedding_for_head_sd = OrderedDict()
+
+    transformer_sd = ds_checkpoint.get_transformer_state(tp_index, pp_index)
+    meg_encoder_sd.update(_convert_ds_transformer_state(transformer_sd))
+
+    if pp_index in [0, ds_checkpoint.pp_degree - 1]:
+        embedding_sd = ds_checkpoint.get_embedding_state(tp_index)
+        nested_embedding_sd = _renest_sd(embedding_sd)
+        if pp_index == 0:
+            meg_embedding_sd.update(nested_embedding_sd)
+
+        if pp_index == ds_checkpoint.pp_degree -1:
+            for key, value in embedding_sd.items():
+                if key.startswith(WORD_EMBEDDINGS_KEY):
+                    fields = key.split('.')
+                    new_fields = fields[1:]
+                    new_key = '.'.join(new_fields)
+                    meg_embedding_for_head_sd[new_key] = value
+
+            final_norm_sd = ds_checkpoint.get_final_norm_state(tp_index)
+            new_final_norm_sd = {f'{FINAL_LAYER_NORM_KEY}.{key}': value for key, value in final_norm_sd.items()}
+            meg_encoder_sd.update(new_final_norm_sd)
+
+    checkpoint_sd = _create_megatron_dict()
+
+    iteration = ds_checkpoint.get_iteration()
+    checkpoint_sd[ITERATION_KEY] = iteration
+    if pp_index == 0:
+        checkpoint_sd[MODEL_KEY][LANGUGAGE_MODEL_KEY][EMBEDDING_KEY] = meg_embedding_sd
+    checkpoint_sd[MODEL_KEY][LANGUGAGE_MODEL_KEY][ENCODER_KEY] = meg_encoder_sd
+    if pp_index == ds_checkpoint.pp_degree -1:
+        checkpoint_sd[MODEL_KEY][WORD_EMBEDDINGS_FOR_HEAD_KEY] = meg_embedding_for_head_sd
+
+    checkpoint_sd[ARGS_KEY] = ds_checkpoint.get_args()
+    # Adjust specific fields
+    checkpoint_sd[ARGS_KEY].tensor_model_parallel_size = ds_checkpoint.tp_degree
+    checkpoint_sd[ARGS_KEY].pipeline_model_parallel_size = ds_checkpoint.pp_degree
+    if for_release:
+        checkpoint_sd[ARGS_KEY].consumed_train_samples = 0
+        checkpoint_sd[ARGS_KEY].consumed_valid_samples = 0
+
+    return checkpoint_sd
+
+
+def _create_latest_file(base_folder, iteration):
+    file_path = os.path.join(base_folder, 'latest_checkpointed_iteration.txt')
+    os.makedirs(base_folder, exist_ok=True)
+    with open(file_path, 'w') as f:
+        f.write(str(iteration))
+
+def main():
+    print(f'Convert DeepSpeed Checkpoint to Megatron Checkpoint')
+
+    args = parse_arguments()
+    print(f'Converting DeepSpeed checkpoint in {args.input_folder} to Megatron checkpoint in {args.output_folder}')
+
+    ds_checkpoint = DeepSpeedCheckpoint(args.input_folder, args.target_tp, args.target_pp)
+    iteration = ds_checkpoint.get_iteration()
+    _create_latest_file(args.output_folder, iteration)
+    checkpoint_paths = _create_checkpoint_paths(args.output_folder, iteration, ds_checkpoint.tp_degree, ds_checkpoint.pp_degree)
+    for i in range(0, ds_checkpoint.tp_degree):
+        for j in range(0, ds_checkpoint.pp_degree):
+            sd = _create_rank_checkpoint(ds_checkpoint, i, j, args.for_release)
+            _save_checkpoint(checkpoint_paths[i][j], sd)
+
+if __name__ == "__main__":
+    main()

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/tools/convert_checkpoint/deepspeed_to_transformers.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python
+
+import os
+import torch
+import json
+
+from deepspeed_checkpoint import DeepSpeedCheckpoint
+from deepspeed_to_megatron import _create_rank_checkpoint, parse_arguments
+
+# the import was tested to work with this version
+# https://github.com/huggingface/transformers/commit/0af901e83 if it diverges we may consider
+# copying that version here instead
+from transformers.models.megatron_gpt2.convert_megatron_gpt2_checkpoint import convert_megatron_checkpoint
+from transformers import GPT2Config
+
+def main():
+
+    # this first part comes mainly from deepspeed_to_megatron.main
+    args = parse_arguments()
+    print(f'Converting DeepSpeed checkpoint in {args.input_folder} to HF Transformers checkpoint in {args.output_folder}')
+
+    ds_checkpoint = DeepSpeedCheckpoint(args.input_folder, args.target_tp, args.target_pp)
+    iteration = ds_checkpoint.get_iteration()
+    input_state_dict = _create_rank_checkpoint(ds_checkpoint, 0, 0, args.for_release)
+
+    # the 2nd part comes from transformers.models.megatron_gpt2.convert_megatron_gpt2_checkpoint.main
+    # Spell out all parameters in case the defaults change.
+    config = GPT2Config(
+        vocab_size=50257,
+        n_positions=1024,
+        n_ctx=1024,
+        n_embd=1024,
+        n_layer=24,
+        n_head=16,
+        n_inner=4096,
+        activation_function="gelu",  # used to be "gelu_new" in earlier versions
+        resid_pdrop=0.1,
+        embd_pdrop=0.1,
+        attn_pdrop=0.1,
+        layer_norm_epsilon=1e-5,
+        initializer_range=0.02,
+        summary_type="cls_index",
+        summary_use_proj=True,
+        summary_activation=None,
+        summary_proj_to_labels=True,
+        summary_first_dropout=0.1,
+        scale_attn_weights=True,
+        gradient_checkpointing=False,
+        use_cache=True,
+        bos_token_id=50256,
+        eos_token_id=50256,
+    )
+
+    # Convert.
+    print("Converting to HF Checkpoint")
+    output_state_dict = convert_megatron_checkpoint(args, input_state_dict, config)
+
+    basename = args.output_folder
+    os.makedirs(basename, exist_ok=True)
+
+    # Print the structure of converted state dict.
+    #if args.print_checkpoint_structure:
+    #    recursive_print(None, output_state_dict)
+
+    # Store the config to file.
+    output_config_file = os.path.join(basename, "config.json")
+    output_config = config.to_dict()
+    output_config["architectures"] = ["GPT2LMHeadModel"]
+    output_config["model_type"] = "gpt2"
+    print(f'Saving config to "{output_config_file}"')
+    with open(output_config_file, "w") as f:
+        json.dump(output_config, f)
+
+    # Store the state_dict to file.
+    output_checkpoint_file = os.path.join(basename, "pytorch_model.bin")
+    print(f'Saving checkpoint to "{output_checkpoint_file}"')
+    torch.save(output_state_dict, output_checkpoint_file)
+
+    print("Now add tokenizer files and upload to the hub")
+
+
+if __name__ == "__main__":
+    main()

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/tools/convert_checkpoint/ds_to_universal.py

@@ -0,0 +1,290 @@
+#!/usr/bin/env python
+
+from collections import OrderedDict
+from functools import partial
+import argparse
+import glob
+import itertools
+import multiprocessing
+import os
+import re
+import shutil
+import torch
+import tqdm
+
+from deepspeed.checkpoint import DeepSpeedCheckpoint
+
+MODEL_KEY = 'model'
+ARGS_KEY = 'args'
+LANGUAGE_MODEL_KEY = 'language_model'
+EMBEDDING_KEY = 'embedding'
+ENCODER_KEY = 'encoder'
+WORD_EMBEDDINGS_FOR_HEAD_KEY = 'word_embeddings_for_head'
+WORD_EMBEDDINGS_KEY = 'word_embeddings'
+FINAL_LAYER_NORM_KEY = 'final_layernorm'
+CHECKPOINT_VERSION_KEY = 'checkpoint_version'
+CHECKPOINT_VERSION_VALUE = 3.0
+ITERATION_KEY = 'iteration'
+ORIGINAL_VOCAB_SIZE = 'original_vocab_size'
+
+
+def parse_arguments():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        '--input_folder',
+        type=str,
+        help='Input DeepSpeed Checkpoint folder')
+    parser.add_argument(
+        '--output_folder',
+        type=str,
+        help='Output Megatron checkpoint folder')
+    parser.add_argument(
+        '--num_extract_workers',
+        default=4,
+        type=int,
+        help='How many parallel processes to extract zero shards')
+    parser.add_argument(
+        '--num_merge_workers',
+        default=2,
+        type=int,
+        help='How many parallel processes to merge tp slices '
+             '(more memory intensive, use much fewer than --num_extract_workers))')
+
+    args = parser.parse_args()
+    print(f'args = {args}')
+    return args
+
+
+def _convert_ds_transformer_state(sd_list):
+    new_sd = OrderedDict()
+    for i, sd in enumerate(sd_list):
+        for key, value in sd.items():
+            new_key = f'layers.{i}.{key}'
+            new_sd[new_key] = value
+
+    return new_sd
+
+
+def _create_megatron_dict():
+    language_model_dict = {EMBEDDING_KEY: {}, ENCODER_KEY: {}}
+    megatron_dict = {
+        MODEL_KEY: {
+            LANGUAGE_MODEL_KEY: language_model_dict
+        },
+        CHECKPOINT_VERSION_KEY: CHECKPOINT_VERSION_VALUE
+    }
+    return megatron_dict
+
+
+def _save_checkpoint(file_path, chkpt_sd):
+    ckp_dir, _ = os.path.split(file_path)
+    os.makedirs(ckp_dir, exist_ok=True)
+    torch.save(chkpt_sd, file_path)
+
+
+def extract_zero_shards(out_path, ds_checkpoint, indices_3d):
+    pp_index, tp_index, dp_index = indices_3d
+    sd = ds_checkpoint.get_zero_checkpoint_state(
+        pp_index=pp_index,
+        tp_index=tp_index,
+        dp_index=dp_index)
+
+    optim_sd = sd["optimizer_state_dict"]
+    param_slice_mappings = optim_sd["param_slice_mappings"]
+
+    # dict
+    state_groups = optim_sd["base_optimizer_state"]["state"]
+
+    # list
+    fp32_groups = optim_sd["single_partition_of_fp32_groups"]
+    param_groups_cnt = len(state_groups)
+
+    for param_group_id in range(param_groups_cnt):
+        flat_state = dict(
+            exp_avg=state_groups[param_group_id]["exp_avg"],
+            exp_avg_sq=state_groups[param_group_id]["exp_avg_sq"],
+            fp32=fp32_groups[param_group_id],
+        )
+
+        for name, fragment_mapping in param_slice_mappings[param_group_id].items():
+            if "tied_modules.embed" in name and pp_index > 0:
+                # Skip word_embeddings.weight that is replicated in first and last pp stages
+                # Skip position_embeddings.weight that is only used in first pp stage
+                continue
+
+            for state_key in flat_state.keys():
+                dump_param_fragment(out_path, tp_index, dp_index, state_key,
+                                    flat_state[state_key], name,
+                                    fragment_mapping.start,
+                                    fragment_mapping.numel)
+
+
+def dump_param_fragment(out_path, tp_index, dp_index, state_name,
+                        state_flat_tensor, param_name, offset, numel):
+    param_base_path = os.path.join(out_path, param_name, str(tp_index))
+    os.makedirs(param_base_path, exist_ok=True)
+
+    counter = f"{dp_index:0>2d}"
+    path = os.path.join(param_base_path, f"{state_name}.{counter}")
+
+    # clone to force tensor storage to ignore views
+    t = state_flat_tensor.narrow(0, offset, numel).clone()
+    _save_checkpoint(path, t)
+
+
+def _merge_zero_shards(param_base_path, state, tp_degree, slice_shape):
+    slices = []
+    for tp_index in range(tp_degree):
+        prefix_path = os.path.join(param_base_path, str(tp_index), f"{state}")
+        paths = sorted(list(glob.glob(f"{prefix_path}.*")))
+        shards = [torch.load(p) for p in paths]
+        param_slice = torch.cat(shards, dim=0).reshape(slice_shape)
+        slices.append(param_slice)
+
+    return slices
+
+
+def _strip_vocab_padding(ds_checkpoint, padded_vocab_tensor):
+    checkpoint_info = ds_checkpoint.get_checkpoint_info()
+    return padded_vocab_tensor.narrow(0, 0, checkpoint_info[ORIGINAL_VOCAB_SIZE])
+
+
+WEIGHTS_TO_AVERAGE_PATTERNS = [
+    r"tied_modules.embed.word_embeddings.norm.weight",
+    r"tied_modules.embed.word_embeddings.norm.bias",
+    r"tied_modules.embed.position_embeddings.weight",
+    r"\d+.input_layernorm.weight",
+    r"\d+.input_layernorm.bias",
+    r"\d+.post_attention_layernorm.weight",
+    r"\d+.post_attention_layernorm.bias",
+    r"\d+.self_attention.dense.bias",
+    r"\d+.attention.dense.bias",
+    r"\d+.mlp.dense_4h_to_h.bias",
+    r"\d+.weight",
+    r"\d+.bias",
+]
+
+WEIGHTS_WITH_ROW_PARALLELISM_CONTAIN = [
+    "dense_4h_to_h.weight",
+    "self_attention.dense.weight",
+    "attention.dense.weight",
+]
+
+
+def _get_vocab_divisibility_padding_tensor(ds_checkpoint, padded_vocab_tensor):
+    checkpoint_info = ds_checkpoint.get_checkpoint_info()
+    if checkpoint_info and padded_vocab_tensor.shape[0] > checkpoint_info[ORIGINAL_VOCAB_SIZE]:
+        return padded_vocab_tensor[-1]
+    else:
+        return torch.zeros(padded_vocab_tensor.shape[1])
+
+
+def _all_same_tensor(arr):
+    assert len(arr) > 0
+    if len(arr) == 1:
+        return True
+    res = all([x.eq(arr[0]).all().item() for x in arr[1:]])
+    return res
+
+
+def merge_tp_slices(ds_checkpoint, out_path, slice_dir, tp_degree, name_and_shape):
+    name, shape = name_and_shape
+    slice_base_path = os.path.join(slice_dir, name)
+    param_base_path = os.path.join(out_path, name)
+
+    for state in ("fp32", "exp_avg", "exp_avg_sq"):
+        slices = _merge_zero_shards(slice_base_path, state, tp_degree, shape)
+        final_path = os.path.join(param_base_path, f"{state}.pt")
+
+        ckpt_dict = {}
+        if any(re.match(pattern, name) for pattern in WEIGHTS_TO_AVERAGE_PATTERNS):
+            assert _all_same_tensor(slices), f'Checkpoint misalignment detected for parameter: {name}'
+            param = slices[0]
+        else:
+            cat_dim = 1 if any(text in name for text in WEIGHTS_WITH_ROW_PARALLELISM_CONTAIN) else 0
+            param = torch.cat(slices, dim=cat_dim)
+            ckpt_dict['cat_dim'] = cat_dim
+
+        if "word_embeddings.weight" in name:
+            # strip padding
+            # param = _strip_vocab_padding(ds_checkpoint, param)
+            ckpt_dict['vocab_divisibility_padding_tensor'] = \
+                _get_vocab_divisibility_padding_tensor(ds_checkpoint, param)
+
+        ckpt_dict['param'] = param
+        _save_checkpoint(final_path, ckpt_dict)
+
+
+def _get_chunks(l, n):
+    for i in range(0, len(l), n):
+        yield l[i:i + n]
+
+
+def _do_parallel_work(do_work, work_chunks, num_workers):
+    pool = multiprocessing.Pool(num_workers)
+    for batch in tqdm.tqdm(work_chunks):
+        pool.map(do_work, batch)
+    pool.close()
+    pool.join()
+
+
+def _extract_zero_shard_files(args, ds_checkpoint, temp_dir):
+    _3d_range_list = list(itertools.product(range(ds_checkpoint.pp_degree),
+                                            range(ds_checkpoint.tp_degree),
+                                            range(ds_checkpoint.dp_degree)))
+    work_chunks = list(_get_chunks(_3d_range_list, args.num_extract_workers))
+
+    do_work = partial(extract_zero_shards, temp_dir, ds_checkpoint)
+    _do_parallel_work(do_work, work_chunks, args.num_extract_workers)
+
+
+def _merge_tp_slice_files(args, ds_checkpoint, slice_shapes, temp_dir):
+    work_chunks = list(_get_chunks(list(slice_shapes.items()), args.num_merge_workers))
+    zero_output_folder = os.path.join(args.output_folder, "zero")
+    do_work = partial(merge_tp_slices, ds_checkpoint, zero_output_folder, temp_dir, ds_checkpoint.tp_degree)
+    _do_parallel_work(do_work, work_chunks, args.num_merge_workers)
+
+
+def main():
+    print(f'Convert DeepSpeed Checkpoint to Universal Checkpoint')
+
+    args = parse_arguments()
+    print(
+        f'Converting DeepSpeed checkpoint in {args.input_folder} '
+        f'to Universal checkpoint in {args.output_folder}'
+    )
+
+    ds_checkpoint = DeepSpeedCheckpoint(args.input_folder)
+
+    slice_shapes = []
+    for mp_rank_file in ds_checkpoint.mp_rank_files:
+        mp_sd = torch.load(mp_rank_file, map_location=torch.device('cpu'))
+        slice_shapes += mp_sd["param_shapes"]
+
+    # fix back to normal flat dict, merge duplicates for tp>1
+    slice_shapes = dict((k, v) for d in slice_shapes for k, v in d.items())
+    temp_dir = os.path.join(args.output_folder, 'tmp')
+
+    print('*** 1. Extracting ZeRO fragments')
+    _extract_zero_shard_files(args, ds_checkpoint, temp_dir)
+
+    print('*** 2. Merging slices')
+    _merge_tp_slice_files(args, ds_checkpoint, slice_shapes, temp_dir)
+
+    shutil.rmtree(temp_dir, ignore_errors=True)
+
+    # Copy mp* files into output folder
+    for f in glob.glob(os.path.join(args.input_folder, 'mp*')):
+        shutil.copy2(f, args.output_folder)
+
+    # Update latest to output folder
+    checkpoint_root_folder, step_folder = os.path.split(args.output_folder)
+    latest_file = os.path.join(checkpoint_root_folder, 'latest_universal')
+    with open(latest_file, "w") as f:
+        f.write(step_folder)
+
+    print('*** Done!')
+
+
+if __name__ == "__main__":
+    main()

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/tools/convert_checkpoint/megatron_optim_merge.py

@@ -0,0 +1,340 @@
+# Copyright (c) 2021-2022, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+import multiprocessing
+from datetime import datetime
+from pathlib import Path
+import os
+import copy
+import numpy as np
+import torch  # pytype: disable=import-error
+import pickle
+
+def save_numpy(optim_state, lyr_name, saved_dir):
+    for opt_key, opt_val in optim_state["state"].items():
+        np.save((saved_dir / F"{lyr_name}.{opt_key}.npy").as_posix(), opt_val.float().cpu().numpy().astype(np.float32))
+    np.save((saved_dir / F"{lyr_name}.fp32_from_fp16_params.npy").as_posix(), optim_state["fp32_from_fp16_params"].float().cpu().numpy().astype(np.float32))
+    with open((saved_dir / F"{lyr_name}.param.pickle").as_posix(), 'wb') as handle:
+        pickle.dump(optim_state["param_groups"], handle, protocol=pickle.HIGHEST_PROTOCOL)
+
+
+# This tool is used to support the new megatron model trained by pipeline parallel + tensor parallel
+def merge(
+    key, pp_id, saved_dir,  model_args, optim_states, ckpt_ver, is_save_numpy
+):
+    #i, pipeline_para_rank, saved_dir, factor, key, model_args, transformer_model_list, ckpt_ver
+    saved_dir = Path(saved_dir)
+    if key.find("layers.") != -1:
+        # key name: language_model.encoder.layers
+        layer_index = (int)(key[30 : key.find(".", 30)])
+        saved_key = key.replace(
+            "layers.%d." % layer_index,
+            "layers.%d."
+            % (layer_index + pp_id * model_args.num_layers // model_args.pipeline_model_parallel_size),
+        )
+        abs_layer_index = "%d" % (layer_index + pp_id * model_args.num_layers // model_args.pipeline_model_parallel_size)
+        abs_layer_dir = "layer_" + abs_layer_index
+        saved_dir = saved_dir / abs_layer_dir
+    else:
+        saved_key = key
+    #major_device = transformer_model_list[0][key].device
+    #print(saved_key)
+    optim_state = copy.deepcopy(optim_states[key])
+    del optim_state['group_index']
+    del optim_state['index_within_group']
+
+    if (
+        key.find("input_layernorm.weight") != -1
+        or key.find("input_layernorm.bias") != -1
+        or key.find("attention.dense.bias") != -1
+        or key.find("post_attention_layernorm.weight") != -1
+        or key.find("post_attention_layernorm.bias") != -1
+        or key.find("mlp.dense_4h_to_h.bias") != -1
+        or key.find("final_layernorm.weight") != -1
+        or key.find("final_layernorm.bias") != -1
+    ):
+        # shared weights, only need to convert the weights from single tp instance
+        for opt_key, opt_val in optim_state["state"].items():
+            optim_state['state'][opt_key] = opt_val[0]
+            #print(F"lyr_name: {key} key: {opt_key}: {optim_state['state'][opt_key].shape}")
+        optim_state["fp32_from_fp16_params"] = optim_state["fp32_from_fp16_params"][0]
+        #print(F"lyr_name: {key} key: fp32_from_fp16_params: {optim_state['fp32_from_fp16_params'].shape}")
+    elif key.find("attention.dense.weight") != -1:
+        state_key = list(optim_state["state"].keys())[0]
+        head_num = model_args.num_attention_heads // model_args.tensor_model_parallel_size
+        hidden_dim = int(optim_state["state"][state_key][0].shape[0])
+        dim_per_head = int(optim_state["state"][state_key][0].shape[1] / head_num)
+        for opt_key, opt_val in optim_state["state"].items():
+            vals = []
+            for k in range(model_args.tensor_model_parallel_size):
+                val = opt_val[k]
+                val = val.reshape(hidden_dim, head_num, dim_per_head)
+                vals.append(val)
+            optim_state['state'][opt_key] = torch.cat(vals, dim=1)
+            #print(F"lyr_name: {key} key: {opt_key}: {optim_state['state'][opt_key].shape}")
+        vals = []
+        for k in range(model_args.tensor_model_parallel_size):
+            val = optim_state["fp32_from_fp16_params"][k]
+            val = val.reshape(hidden_dim, head_num, dim_per_head)
+            vals.append(val)
+        optim_state["fp32_from_fp16_params"] = torch.cat(vals, dim=1)
+        #print(F"lyr_name: {key} key: fp32_from_fp16_params: {optim_state['fp32_from_fp16_params'].shape}")
+    elif key.find("mlp.dense_4h_to_h.weight") != -1:
+        for opt_key, opt_val in optim_state["state"].items():
+            vals = []
+            for k in range(model_args.tensor_model_parallel_size):
+                vals.append(opt_val[k])
+            optim_state['state'][opt_key] = torch.cat(vals, dim=-1)
+            #print(F"lyr_name: {key} key: {opt_key}: {optim_state['state'][opt_key].shape}")
+        vals = []
+        for k in range(model_args.tensor_model_parallel_size):
+            vals.append(optim_state["fp32_from_fp16_params"][k])
+        optim_state["fp32_from_fp16_params"] = torch.cat(vals, dim=-1)
+        #print(F"lyr_name: {key} key: fp32_from_fp16_params: {optim_state['fp32_from_fp16_params'].shape}")
+    elif key.find("mlp.dense_h_to_4h.weight") != -1 or key.find("mlp.dense_h_to_4h.bias") != -1:
+        for opt_key, opt_val in optim_state["state"].items():
+            vals = []
+            for k in range(model_args.tensor_model_parallel_size):
+                vals.append(opt_val[k])
+            optim_state['state'][opt_key] = torch.cat(vals, dim=0)
+            #print(F"lyr_name: {key} key: {opt_key}: {optim_state['state'][opt_key].shape}")
+        vals = []
+        for k in range(model_args.tensor_model_parallel_size):
+            vals.append(optim_state["fp32_from_fp16_params"][k])
+        optim_state["fp32_from_fp16_params"] = torch.cat(vals, dim=0)
+        #print(F"lyr_name: {key} key: fp32_from_fp16_params: {optim_state['fp32_from_fp16_params'].shape}")
+    elif key.find("attention.query_key_value.bias") != -1:
+        state_key = list(optim_state["state"].keys())[0]
+        num_splits = 3
+        head_num = model_args.num_attention_heads // model_args.tensor_model_parallel_size
+        size_per_head = int(optim_state["state"][state_key][0].shape[0] / num_splits / head_num)
+        for opt_key, opt_val in optim_state["state"].items():
+            vals = []
+            for k in range(model_args.tensor_model_parallel_size):
+                val = opt_val[k]
+                val = val.reshape(head_num, num_splits, size_per_head)
+                vals.append(val)
+            optim_state['state'][opt_key] = torch.cat(vals, dim=0)
+            #print(F"lyr_name: {key} key: {opt_key}: {optim_state['state'][opt_key].shape}")
+        vals = []
+        for k in range(model_args.tensor_model_parallel_size):
+            val = optim_state["fp32_from_fp16_params"][k]
+            val = val.reshape(head_num, num_splits, size_per_head)
+            vals.append(val)
+        optim_state["fp32_from_fp16_params"] = torch.cat(vals, dim=0)
+        #print(F"lyr_name: {key} key: fp32_from_fp16_params: {optim_state['fp32_from_fp16_params'].shape}")
+    elif key.find("attention.query_key_value.weight") != -1:
+        state_key = list(optim_state["state"].keys())[0]
+        num_splits = 3
+        hidden_dim = int(optim_state["state"][state_key][0].shape[1])
+        head_num = model_args.num_attention_heads // model_args.tensor_model_parallel_size
+        size_per_head = int(optim_state["state"][state_key][0].shape[0] / num_splits / head_num)
+        for opt_key, opt_val in optim_state["state"].items():
+            vals = []
+            for k in range(model_args.tensor_model_parallel_size):
+                val = opt_val[k]
+                val = val.reshape(head_num, num_splits, size_per_head, hidden_dim)
+                vals.append(val)
+            optim_state['state'][opt_key] = torch.cat(vals, dim=0)
+            #print(F"lyr_name: {key} key: {opt_key}: {optim_state['state'][opt_key].shape}")
+        vals = []
+        for k in range(model_args.tensor_model_parallel_size):
+            val = optim_state["fp32_from_fp16_params"][k]
+            val = val.reshape(head_num, num_splits, size_per_head, hidden_dim)
+            vals.append(val)
+        optim_state["fp32_from_fp16_params"] = torch.cat(vals, dim=0)
+        #print(F"lyr_name: {key} key: fp32_from_fp16_params: {optim_state['fp32_from_fp16_params'].shape}")
+    else:
+        print(f"[ERROR] cannot find key '{key}'")
+        exit(1)
+
+    #print(F"{saved_key}: {tmp.shape}")
+    if is_save_numpy:
+        save_numpy(optim_state, saved_key, saved_dir)
+    else:
+        saved_path = saved_dir / f"{saved_key}.pt"
+        torch.save(optim_state, saved_path)
+
+def merge_checkpoint(args):
+    saved_dir = Path(args.saved_dir) / "gpu" / "optimizer"
+    saved_dir.mkdir(parents=True, exist_ok=True)
+
+    prefix = Path(args.in_dir)
+    ckpt_name = "model_optim_rng.pt"
+
+    # load position_embedding from rank 0
+    if (prefix / "mp_rank_00").is_dir():
+        model_00 = torch.load((prefix / "mp_rank_00" / ckpt_name).as_posix())
+    elif (prefix / "mp_rank_00_000").is_dir():
+        model_00 = torch.load((prefix / "mp_rank_00_000" / ckpt_name).as_posix())
+    else:
+        print(f"[ERROR] Cannot find checkpoint in {prefix}.")
+        exit(1)
+
+    model_args = model_00["args"]
+    with open((saved_dir / "args.txt").as_posix(), "w") as f:
+        for k, v in vars(model_args).items():
+            f.write(f"{k}:{v} \n")
+
+    del model_00
+
+    tp_size = model_args.tensor_model_parallel_size
+
+    for i in range(model_args.num_layers):
+        pp_id_dir = (saved_dir / f"layer_{i}").as_posix()
+        os.makedirs(pp_id_dir, exist_ok=True)
+
+    torch.multiprocessing.set_start_method("spawn")
+    torch.multiprocessing.set_sharing_strategy("file_system")
+    pool = multiprocessing.Pool(args.pool)
+    w_e_list = []
+    w_e_h_list = []
+    #for pp_id in [2]:
+    for pp_id in range(model_args.pipeline_model_parallel_size):
+        if model_args.pipeline_model_parallel_size == 1:
+            layer_rank_num = ""
+        else:
+            layer_rank_num = f"_{pp_id:03d}"
+        optim_states = {}
+        for tp_id in range(tp_size):
+            #if tp_id == 0:
+            print(F"Loading ckpt file from: mp_rank_{tp_id:02d}{layer_rank_num}")
+            m = torch.load((prefix / f"mp_rank_{tp_id:02d}{layer_rank_num}" / ckpt_name).as_posix(), map_location="cpu")
+            #m["model"]["language_model"]["encoder"] = {key: value for key, value in m["model"]["language_model"]["encoder"].items() if ("attention.dense.weight" in key) or ("mlp.dense_4h_to_h.weight" in key)}
+            #print(m["model"]["language_model"]["encoder"].keys())
+            target_optim_map_orig = m['optimizer_model_map']
+            target_optim_map = copy.deepcopy(target_optim_map_orig)
+            substr = "module.module."
+            for key, value in target_optim_map.items():
+                if value.startswith(substr):
+                    target_optim_map[key] = value[len(substr):]
+            #del target_optim_map_orig
+            #for key, value in m["optimizer_model_map"].items():
+            for key, value in target_optim_map.items():
+                if value in optim_states:
+                    for opt_key, opt_val in m["optimizer"]["optimizer"]["state"][key].items():
+                        optim_states[value]["state"][opt_key].append(opt_val)
+                    group_index = optim_states[value]["group_index"]
+                    index_within_group = optim_states[value]["index_within_group"]
+                    optim_states[value]["fp32_from_fp16_params"].append(m["optimizer"]["fp32_from_fp16_params"][group_index][index_within_group])
+                else:
+                    optim_states[value] = {}
+                    optim_states[value]["state"] = {}
+                    for opt_key, opt_val in m["optimizer"]["optimizer"]["state"][key].items():
+                        optim_states[value]["state"][opt_key] = []
+                        optim_states[value]["state"][opt_key].append(opt_val)
+                    # Find index param group
+                    group_index = 0
+                    index_within_group = 0
+                    for index, group in enumerate(m["optimizer"]["optimizer"]["param_groups"]):
+                        if key in group["params"]:
+                            group_index = index
+                            index_within_group = group["params"].index(key)
+                            optim_states[value]["group_index"] = group_index
+                            optim_states[value]["index_within_group"] = index_within_group
+                            optim_states[value]["param_groups"] = copy.deepcopy(group)
+                            if "params" in optim_states[value]["param_groups"]:
+                                del optim_states[value]["param_groups"]["params"]
+                            break
+                    if "group_index" not in optim_states[value]:
+                        print(F"couldn't find index for layer: {value}")
+                        exit(1)
+                    optim_states[value]["fp32_from_fp16_params"] = []
+                    optim_states[value]["fp32_from_fp16_params"].append(m["optimizer"]["fp32_from_fp16_params"][group_index][index_within_group])
+
+        if pp_id == 0:
+            lyr_name = 'language_model.embedding.word_embeddings.weight'
+            optim_state = copy.deepcopy(optim_states[lyr_name])
+            for opt_key, opt_val in optim_state["state"].items():
+                optim_state['state'][opt_key] = torch.cat(opt_val, dim=0)
+                #print(F"lyr_name: {lyr_name} key: {opt_key}: {optim_state['state'][opt_key].shape}")
+            optim_state["fp32_from_fp16_params"] = torch.cat(optim_state["fp32_from_fp16_params"], dim=0)
+            #print(F"lyr_name: {lyr_name} key: fp32_from_fp16_params: {optim_state['fp32_from_fp16_params'].shape}")
+            del optim_state['group_index']
+            del optim_state['index_within_group']
+            if args.save_numpy:
+                 save_numpy(optim_state, lyr_name, saved_dir)
+            else:
+                torch.save(optim_state, (saved_dir / F"{lyr_name}.pt").as_posix())
+            del optim_states[lyr_name]
+
+            lyr_name = 'language_model.embedding.position_embeddings.weight'
+            optim_state = copy.deepcopy(optim_states[lyr_name])
+            for opt_key, opt_val in optim_state["state"].items():
+                optim_state['state'][opt_key] = opt_val[0]
+                #print(F"lyr_name: {lyr_name} key: {opt_key}: {optim_state['state'][opt_key].shape}")
+            optim_state["fp32_from_fp16_params"] = optim_state["fp32_from_fp16_params"][0]
+            #print(F"lyr_name: {lyr_name} key: fp32_from_fp16_params: {optim_state['fp32_from_fp16_params'].shape}")
+            del optim_state['group_index']
+            del optim_state['index_within_group']
+            if args.save_numpy:
+                 save_numpy(optim_state, lyr_name, saved_dir)
+            else:
+                torch.save(optim_state, (saved_dir / F"{lyr_name}.pt").as_posix())
+            del optim_states[lyr_name]
+
+        if pp_id == (model_args.pipeline_model_parallel_size - 1) and model_args.pipeline_model_parallel_size > 1:
+            lyr_name = 'word_embeddings.weight'
+            optim_state = copy.deepcopy(optim_states[lyr_name])
+            for opt_key, opt_val in optim_state["state"].items():
+                optim_state['state'][opt_key] = torch.cat(opt_val, dim=0)
+                #print(F"lyr_name: {lyr_name} key: {opt_key}: {optim_state['state'][opt_key].shape}")
+            optim_state["fp32_from_fp16_params"] = torch.cat(optim_state["fp32_from_fp16_params"], dim=0)
+            #print(F"lyr_name: {lyr_name} key: fp32_from_fp16_params: {optim_state['fp32_from_fp16_params'].shape}")
+            del optim_state['group_index']
+            del optim_state['index_within_group']
+            if args.save_numpy:
+                save_numpy(optim_state, lyr_name, saved_dir)
+            else:
+                torch.save(optim_state, (saved_dir / F"{lyr_name}.pt").as_posix())
+            del optim_states[lyr_name]
+
+        pool.starmap(
+            merge,
+            [
+                (
+                    k,
+                    pp_id,
+                    saved_dir,
+                    model_args,
+                    optim_states,
+                    m["checkpoint_version"],
+                    args.save_numpy
+                )
+                for (k, _) in optim_states.items()
+            ],
+        )
+
+    pool.close()
+    pool.join()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(formatter_class=argparse.RawTextHelpFormatter)
+    parser.add_argument("-saved_dir", "-o", type=str, help="output directory for saving converted checkpoints", required=True)
+    parser.add_argument("-in_dir", "-i", type=str, help="input checkpoint directory path", required=True)
+    parser.add_argument("-save_numpy", "-npy", action='store_true', help="save output as numpy array", default=False)
+    parser.add_argument("-pool", "-pl", type=int, help="Process pool", default=4)
+    args = parser.parse_args()
+    print("\n=============== Argument ===============")
+    for key in vars(args):
+        print(f"{key}: {vars(args)[key]}")
+    print("========================================")
+
+    start_time = datetime.now()
+    merge_checkpoint(args)
+    stop_time = datetime.now()
+    run_time = stop_time - start_time
+    print(f"[INFO] Spent {run_time} (h:m:s) to convert the model")

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/tools/convert_checkpoint/megatron_optim_merged_to_ds_universal_convert.py

@@ -0,0 +1,321 @@
+###############################################################################
+# Copyright (c) 2023 Habana Labs Ltd.  All rights reserved.
+###############################################################################
+import argparse
+import multiprocessing
+from datetime import datetime
+from pathlib import Path
+import os
+import copy
+import numpy as np
+import torch  # pytype: disable=import-error
+import pickle
+import glob
+import re
+
+
+WEIGHTS_TO_AVERAGE_PATTERNS = [
+    r"tied_modules.embed.word_embeddings.norm.weight",
+    r"tied_modules.embed.word_embeddings.norm.bias",
+    r"tied_modules.embed.position_embeddings.weight",
+    r"\d+.input_layernorm.weight",
+    r"\d+.input_layernorm.bias",
+    r"\d+.post_attention_layernorm.weight",
+    r"\d+.post_attention_layernorm.bias",
+    r"\d+.self_attention.dense.bias",
+    r"\d+.attention.dense.bias",
+    r"\d+.mlp.dense_4h_to_h.bias",
+    r"\d+.weight",
+    r"\d+.bias",
+]
+
+WEIGHTS_WITH_ROW_PARALLELISM_CONTAIN = [
+    "dense_4h_to_h.weight",
+    "self_attention.dense.weight",
+    "attention.dense.weight",
+]
+def _get_vocab_divisibility_padding_tensor(padded_vocab_tensor):
+    return padded_vocab_tensor[-1]
+
+def _save_checkpoint(file_path, chkpt_sd):
+    ckp_dir, _ = os.path.split(file_path)
+    os.makedirs(ckp_dir, exist_ok=True)
+    torch.save(chkpt_sd, file_path)
+
+def tensor_convert(tensor_name_mapping, tensor_index):
+    fp32_ckpt = {}
+    exp_avg_ckpt = {}
+    exp_avg_sq_ckpt = {}
+
+    tensor_name = tensor_name_mapping[tensor_index]
+    megatron_optimizer_states = torch.load(tensor_name[1])
+    if 'self_attention.query_key_value' in tensor_name[1]:
+        dim = megatron_optimizer_states['fp32_from_fp16_params'].size()[len(megatron_optimizer_states['fp32_from_fp16_params'].size())-1]
+        fp32_ckpt['param'] = megatron_optimizer_states['fp32_from_fp16_params'].view(-1,dim)
+        exp_avg_ckpt['param'] = megatron_optimizer_states['state']['exp_avg'].view(-1,dim)
+        exp_avg_sq_ckpt['param'] = megatron_optimizer_states['state']['exp_avg_sq'].view(-1,dim)
+
+        cat_dim = 0
+        fp32_ckpt['cat_dim'] = cat_dim
+        exp_avg_ckpt['cat_dim'] = cat_dim
+        exp_avg_sq_ckpt['cat_dim'] = cat_dim
+    else:
+        fp32_ckpt['param'] = megatron_optimizer_states['fp32_from_fp16_params']
+        exp_avg_ckpt['param'] = megatron_optimizer_states['state']['exp_avg']
+        exp_avg_sq_ckpt['param'] = megatron_optimizer_states['state']['exp_avg_sq']
+
+    ds_tensor_name = os.path.split(tensor_name[0])[-1]
+    if not any(re.match(pattern, ds_tensor_name) for pattern in WEIGHTS_TO_AVERAGE_PATTERNS):
+        cat_dim = 1 if any(text in ds_tensor_name for text in WEIGHTS_WITH_ROW_PARALLELISM_CONTAIN) else 0
+        if '.bias' not in ds_tensor_name:
+            fp32_ckpt['cat_dim'] = cat_dim
+            exp_avg_ckpt['cat_dim'] = cat_dim
+            exp_avg_sq_ckpt['cat_dim'] = cat_dim
+
+    if 'word_embeddings.weight' in tensor_name[1]:
+        fp32_ckpt['vocab_divisibility_padding_tensor'] = \
+            _get_vocab_divisibility_padding_tensor(fp32_ckpt['param'])
+        exp_avg_ckpt['vocab_divisibility_padding_tensor'] = \
+            _get_vocab_divisibility_padding_tensor(exp_avg_ckpt['param'])
+        exp_avg_sq_ckpt['vocab_divisibility_padding_tensor'] = \
+            _get_vocab_divisibility_padding_tensor(exp_avg_sq_ckpt['param'])
+
+
+    fp32_weight_file_path = os.path.join(tensor_name[0], 'fp32.pt')
+    _save_checkpoint(fp32_weight_file_path, fp32_ckpt)
+
+    exp_avg_file_path = os.path.join(tensor_name[0], 'exp_avg.pt')
+    _save_checkpoint(exp_avg_file_path, exp_avg_ckpt)
+
+    exp_avg_sq_file_path = os.path.join(tensor_name[0], 'exp_avg_sq.pt')
+    _save_checkpoint(exp_avg_sq_file_path, exp_avg_sq_ckpt)
+
+def mp_rank_files_info_adjustment(file,megatron_state_dict,same_config, ds_universal_checkpoints_path):
+    ds_state_dict = torch.load(file, map_location=torch.device('cpu'))
+    ds_state_dict['lr_scheduler']['num_steps'] = megatron_state_dict['opt_param_scheduler']['num_steps']
+    ds_state_dict['lr_scheduler']['warmup_steps'] = megatron_state_dict['opt_param_scheduler']['warmup_steps']
+    ds_state_dict['lr_scheduler']['decay_steps'] = megatron_state_dict['opt_param_scheduler']['decay_steps']
+    ds_state_dict['iteration'] = megatron_state_dict['iteration']
+    ds_state_dict['global_steps'] = megatron_state_dict['iteration']
+    ds_state_dict['global_samples'] = megatron_state_dict['args'].consumed_train_samples
+    ds_state_dict['tokens'] = megatron_state_dict['args'].consumed_train_samples* megatron_state_dict['args'].seq_length
+    ds_state_dict['args'].consumed_train_samples = megatron_state_dict['args'].consumed_train_samples
+    ds_state_dict['args'].consumed_valid_samples = megatron_state_dict['args'].consumed_valid_samples
+    ds_state_dict['args'].consumed_train_tokens = ds_state_dict['tokens']
+
+    # if both megatron-lm and megatron-deepspeed have the same TP, PP configuration, we copy the rng states from megatron-lm to megatron-deepspeed
+    if same_config == 'True':
+        ds_state_dict['random_rng_state'] = megatron_state_dict['rng_state'][0]['random_rng_state']
+        ds_state_dict['np_rng_state'] = megatron_state_dict['rng_state'][0]['np_rng_state']
+        ds_state_dict['torch_rng_state'] = megatron_state_dict['rng_state'][0]['torch_rng_state']
+        ds_state_dict['cuda_rng_state'] = megatron_state_dict['rng_state'][0]['cuda_rng_state']
+        ds_state_dict['rng_tracker_states'] = megatron_state_dict['rng_state'][0]['rng_tracker_states']
+
+    file = os.path.join(ds_universal_checkpoints_path,os.path.split(file)[1])
+    torch.save(ds_state_dict,file)
+
+
+def mp_rank_files_info_adjustment_parallel_processing(ds_mp_rank_files_dir,ds_universal_checkpoints_path,megatron_lm_non_merged_input_dir, \
+                                                       model_parallel_same_config,pp_index,tp_index,tp_rank):
+
+     state_dict = torch.load(os.path.join(megatron_lm_non_merged_input_dir,
+                                          'mp_rank_{:02d}_{:03d}'.format(
+                                              tp_index,
+                                              pp_index),
+                                          'model_optim_rng.pt'), map_location=torch.device('cpu'))
+
+     # Need to update according to how the mapping is done when tp_rank * pp_rank > 9
+     mp_rank_file_index = '0' + str(pp_index * tp_rank + tp_index)
+     mp_rank_file = os.path.join(ds_mp_rank_files_dir, 'mp_rank_' + mp_rank_file_index + '_model_states.pt')
+     mp_rank_files_info_adjustment(mp_rank_file, state_dict, model_parallel_same_config, ds_universal_checkpoints_path)
+
+
+
+def ds_universal_convert(args):
+
+    torch.multiprocessing.set_start_method("spawn")
+    torch.multiprocessing.set_sharing_strategy("file_system")
+    pool = multiprocessing.Pool(args.pool)
+
+    ds_universal_checkpoints_path = args.ds_universal_dir
+    latest_file = os.path.join(ds_universal_checkpoints_path, 'latest_universal')
+    os.makedirs(ds_universal_checkpoints_path, exist_ok=True)
+    with open(latest_file, "w") as f:
+        f.write(str(args.iteration))
+
+    ds_universal_checkpoints_path = os.path.join(ds_universal_checkpoints_path, str(args.iteration))
+    os.makedirs(ds_universal_checkpoints_path, exist_ok=True)
+
+    if (args.update_only_mp_rank_files == False):
+        layers_per_model_pipeline_slice = args.num_layers // args.pp_rank
+        # tensor_name_mapping maps the ds tensor directory name to the megatron-lm merged optimizer tensor path
+        if args.pp_rank == 1:
+            tensor_name_mapping = [
+                [os.path.join(ds_universal_checkpoints_path, 'zero', 'tied_modules.embed.position_embeddings.weight'),os.path.join(args.megatron_lm_merged_input_dir, 'language_model.embedding.position_embeddings.weight.pt')], \
+                [os.path.join(ds_universal_checkpoints_path, 'zero', 'tied_modules.embed.word_embeddings.weight'), os.path.join(args.megatron_lm_merged_input_dir, 'language_model.embedding.word_embeddings.weight.pt')],
+                [os.path.join(ds_universal_checkpoints_path, 'zero', str(4 + args.num_layers) + '.bias'), os.path.join(args.megatron_lm_merged_input_dir, 'language_model.encoder.final_layernorm.bias.pt')],
+                [os.path.join(ds_universal_checkpoints_path, 'zero', str(4 + args.num_layers) + '.weight'), os.path.join(args.megatron_lm_merged_input_dir, 'language_model.encoder.final_layernorm.weight.pt')]
+            ]
+        else:
+            tensor_name_mapping =   [
+                                [os.path.join(ds_universal_checkpoints_path, 'zero','tied_modules.embed.position_embeddings.weight'), os.path.join(args.megatron_lm_merged_input_dir,'language_model.embedding.position_embeddings.weight.pt')], \
+                                [os.path.join(ds_universal_checkpoints_path, 'zero','tied_modules.embed.word_embeddings.weight'), os.path.join(args.megatron_lm_merged_input_dir,'language_model.embedding.word_embeddings.weight.pt')],
+                                [os.path.join(ds_universal_checkpoints_path, 'zero','word_embeddings.weight'),os.path.join(args.megatron_lm_merged_input_dir,'word_embeddings.weight.pt')], \
+                                [os.path.join(ds_universal_checkpoints_path, 'zero',str(4+args.num_layers)+'.bias'), os.path.join(args.megatron_lm_merged_input_dir,'language_model.encoder.final_layernorm.bias.pt')],
+                                [os.path.join(ds_universal_checkpoints_path, 'zero',str(4+args.num_layers)+'.weight'),os.path.join(args.megatron_lm_merged_input_dir,'language_model.encoder.final_layernorm.weight.pt')]
+                ]
+
+        layer_name_mapping =    [
+                                ['.attention.dense.bias', 'language_model.encoder.layers.LAYER_INDEX.self_attention.dense.bias'], \
+                                ['.attention.dense.weight','language_model.encoder.layers.LAYER_INDEX.self_attention.dense.weight'], \
+                                ['.attention.query_key_value.bias', 'language_model.encoder.layers.LAYER_INDEX.self_attention.query_key_value.bias'], \
+                                ['.attention.query_key_value.weight', 'language_model.encoder.layers.LAYER_INDEX.self_attention.query_key_value.weight'], \
+                                ['.input_layernorm.bias', 'language_model.encoder.layers.LAYER_INDEX.input_layernorm.bias'], \
+                                ['.input_layernorm.weight', 'language_model.encoder.layers.LAYER_INDEX.input_layernorm.weight'], \
+                                ['.mlp.dense_4h_to_h.bias', 'language_model.encoder.layers.LAYER_INDEX.mlp.dense_4h_to_h.bias'], \
+                                ['.mlp.dense_4h_to_h.weight', 'language_model.encoder.layers.LAYER_INDEX.mlp.dense_4h_to_h.weight'], \
+                                ['.mlp.dense_h_to_4h.bias', 'language_model.encoder.layers.LAYER_INDEX.mlp.dense_h_to_4h.bias'], \
+                                ['.mlp.dense_h_to_4h.weight', 'language_model.encoder.layers.LAYER_INDEX.mlp.dense_h_to_4h.weight'], \
+                                ['.post_attention_layernorm.bias', 'language_model.encoder.layers.LAYER_INDEX.post_attention_layernorm.bias'], \
+                                ['.post_attention_layernorm.weight', 'language_model.encoder.layers.LAYER_INDEX.post_attention_layernorm.weight']
+                ]
+
+        for layer_index in np.arange(args.num_layers):
+            for layer_tensor_index in np.arange(len(layer_name_mapping)):
+
+                ds_tensor_name_map = os.path.join(ds_universal_checkpoints_path,'zero',str(3+layer_index)+layer_name_mapping[layer_tensor_index][0])
+                megatron_tensor_name_map = os.path.join(args.megatron_lm_merged_input_dir,'layer_'+str(layer_index),layer_name_mapping[layer_tensor_index][1].replace('LAYER_INDEX',str(layer_index))+'.pt')
+                tensor_name_map = [ds_tensor_name_map, megatron_tensor_name_map]
+                tensor_name_mapping.append(tensor_name_map)
+
+
+        # go over all the tensors in tensor_name_mapping and convert them from megatron optimizer format to ds_universal
+
+        #for tensors_index in np.arange(len(tensor_name_mapping)):
+        #    tensor_convert(tensor_name_mapping,tensors_index)
+        #    print('finished converting tensor {}'.format(tensors_index))
+
+        # multiprocessing of the tensors in tensor_name_mapping and converting them from megatron optimizer format to ds_universal
+
+        pool.starmap(
+            tensor_convert,
+            [
+                (
+                    tensor_name_mapping,
+                    k
+                )
+                for k in np.arange(len(tensor_name_mapping))
+            ],
+        )
+
+        pool.close()
+        pool.join()
+
+
+    # updating the deepspeed ds_mp_rank files according to megatron non merged ( original megatron checkpoint structure files)
+
+    if args.model_parallel_same_config == 'True':
+        for pp_index in np.arange(args.pp_rank):
+            for tp_index in np.arange(args.tp_rank):
+                if args.pp_rank > 1:
+                    file_name = os.path.join(args.megatron_lm_non_merged_input_dir,'mp_rank_{:02d}_{:03d}'.format(tp_index,pp_index),'model_optim_rng.pt')
+                else:
+                    file_name = os.path.join(args.megatron_lm_non_merged_input_dir,'mp_rank_{:02d}'.format(tp_index),'model_optim_rng.pt')
+
+                state_dict = torch.load(file_name, map_location=torch.device('cpu'))
+
+                # Need to update according to how the mapping is done when tp_rank * pp_rank > 9
+                mp_rank_file_index = '0'+str(pp_index*args.tp_rank+tp_index)
+                mp_rank_file = os.path.join(args.ds_mp_rank_files_dir,'mp_rank_'+mp_rank_file_index+'_model_states.pt')
+                mp_rank_files_info_adjustment(mp_rank_file, state_dict, args.model_parallel_same_config,
+                                                  ds_universal_checkpoints_path)
+
+
+        
+        model_parallel_matrix_index = []
+        for pp_index in np.arange(args.pp_rank):
+            for tp_index in np.arange(args.tp_rank):
+                model_parallel_matrix_index.append([pp_index, tp_index])
+    
+        
+        pool = multiprocessing.Pool(args.pool)
+    
+        pool.starmap(
+            mp_rank_files_info_adjustment_parallel_processing,
+            [
+                (
+                    args.ds_mp_rank_files_dir,
+                    ds_universal_checkpoints_path,
+                    args.megatron_lm_non_merged_input_dir,
+                    args.model_parallel_same_config,
+                    pp_index,
+                    tp_index,
+                    args.tp_rank
+                )
+                for (pp_index, tp_index) in model_parallel_matrix_index
+            ],
+        )
+    
+        pool.close()
+        pool.join()
+
+    else:
+        mp_rank_files = glob.glob(os.path.join(args.ds_mp_rank_files_dir, 'mp_rank_*.pt'))
+        if args.megatron_lm_non_merged_input_dir is not None:
+            file_name = glob.glob(os.path.join(args.megatron_lm_non_merged_input_dir,'*'))[0]+'/model_optim_rng.pt'
+            megatron_state_dict = torch.load(file_name, map_location=torch.device('cpu'))
+
+        else:
+            class My_args:
+                def __init__(self, consumed_train_samples=args.iteration * args.global_batch_size, seq_length=args.seq_length, consumed_valid_samples=0):
+                    self.consumed_train_samples = consumed_train_samples
+                    self.seq_length = seq_length
+                    self.consumed_valid_samples = consumed_valid_samples
+
+            megatron_state_dict = { 'opt_param_scheduler': args.iteration, 'iteration': args.iteration, 'args' : None }
+            megatron_state_dict['opt_param_scheduler'] = {'num_steps': args.iteration*args.global_batch_size, 'warmup_steps':  args.lr_warmup_samples  , 'decay_steps': args.lr_decay_samples}
+            megatron_state_dict['args']= My_args(consumed_train_samples=args.iteration * args.global_batch_size,
+                                                seq_length=args.seq_length)
+
+        for mp_rank_file in mp_rank_files:
+            print(f"Adjusting {mp_rank_file=}", flush=True)
+            mp_rank_files_info_adjustment(mp_rank_file, megatron_state_dict, args.model_parallel_same_config, ds_universal_checkpoints_path)
+        # Deleting redundant mp_rank files, in case number of devices was decreased
+        universal_mp_rank_files = glob.glob(os.path.join(ds_universal_checkpoints_path, 'mp_rank_*.pt'))
+        for universal_mp_rank_file in universal_mp_rank_files:
+            if os.path.basename(universal_mp_rank_file) not in [os.path.basename(file_elem) for file_elem in mp_rank_files]:
+                print(f"Deleting old redundant mp_rank file {universal_mp_rank_file=}", flush=True)
+                os.remove(universal_mp_rank_file)
+
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(formatter_class=argparse.RawTextHelpFormatter)
+    parser.add_argument("--ds-universal-dir", "--o", type=str, help="output directory for saving the converted ds_universal checkpoints", required=True)
+    parser.add_argument("--megatron-lm-merged-input-dir", "--merged-input", type=str, help="megatron-lm merged optimizer input checkpoint directory path", required=False)
+    parser.add_argument("--megatron-lm-non-merged-input-dir", "--non-merged-input", type=str, help="megatron-lm non merged checkpoint directory path", default = None)
+    parser.add_argument("--ds-mp-rank-files-dir", "--ds", type=str, help="deepspeed mp_rank_files directory path", required=True)
+    parser.add_argument("--tp-rank", "--tp",type=int, help="deepseed tp_rank configuration", default=8,required=True)
+    parser.add_argument("--pp-rank", "--pp",type=int, help="deepseed tp_rank configuration", default=8,required=True)
+    parser.add_argument("--num-layers", "--nl", type=int, help="GPT-3 number of layers", default=96)
+    parser.add_argument("--iteration", "--iter", type=int, help="#iteration ", default=None, required=True)
+    parser.add_argument("--global-batch-size", "--gbs", type=int, help="load ckpt global batch size", default=1536)
+    parser.add_argument("--seq_length", "--sl", type=int, help="Sequence length", default=2048)
+    parser.add_argument("--lr-warmup-samples", "--lws", type=int, help="lr warmup samples", default=407040)
+    parser.add_argument("--lr-decay-samples", "--lds", type=int, help="lr decay samples", default=166809600)
+    parser.add_argument("--model-parallel-same-config", "--same_config", help="if megatron-lm and megatron deepspeed tp, pp configuration is the same", default=True)
+    parser.add_argument("--pool", "-pl", type=int, help="Process pool", default=4)
+    parser.add_argument("--update-only-mp-rank-files", "--update", type=bool, help="if set will update only the mp_rank files w/o converting the nvidia-merged format to ds universal ", default=False, required=False)
+
+    args = parser.parse_args()
+    print("\n=============== Argument ===============")
+    for key in vars(args):
+        print(f"{key}: {vars(args)[key]}")
+    print("========================================")
+
+    print("Converting megatron merged optimizer checkpoint to deepspeed universal format checkpoint")
+    start_time = datetime.now()
+    ds_universal_convert(args)
+    stop_time = datetime.now()
+    run_time = stop_time - start_time
+    print(f"[INFO] Spent {run_time} (h:m:s) to convert the merged optimizer to deepspeed universal format")

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/tools/convert_checkpoint/verify_checkpoint_non_tp_consistency.py

@@ -0,0 +1,290 @@
+import re
+import tqdm
+import argparse
+from dataclasses import dataclass
+import torch
+from deepspeed.checkpoint import DeepSpeedCheckpoint
+
+
+def parse_arguments():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--folder', default=None, type=str, help='DeepSpeed Checkpoint folder')
+    parser.add_argument('--model_type', default='GPT', type=str, help='Type of the model',
+                        choices=['GPT', 'BLOOM', 'LLAMA'])
+    parser.add_argument('--sequence-parallel', action='store_true', help='Is sequence parallel enabled')
+    args = parser.parse_args()
+    print(f'args = {args}')
+    return args
+
+
+def show_3d(ds_checkpoint):
+    src_3d = ds_checkpoint.zero_checkpoint.src_3d
+    dp, tp, pp = src_3d.dp_degree, src_3d.tp_degree, src_3d.pp_degree
+    print(f'3D configuration: DP={dp} TP={tp} PP={pp}')
+
+
+def get_layer_patterns_for_non_sharded(model_type):
+    if model_type == 'GPT':
+      return [
+          'position_embeddings.weight',
+          'input_layernorm.weight',
+          'input_layernorm.bias',
+          'self_attention.dense.bias',
+          "attention.dense.bias",
+          'post_attention_layernorm.weight',
+          'post_attention_layernorm.bias',
+          'mlp.dense_4h_to_h.bias',
+          'weight',
+          'bias'
+      ]
+
+    if model_type == 'BLOOM':
+      return [
+          'input_layernorm.weight',
+          'input_layernorm.bias',
+          'self_attention.dense.bias',
+          "attention.dense.bias",
+          'post_attention_layernorm.weight',
+          'post_attention_layernorm.bias',
+          'mlp.dense_4h_to_h.bias',
+          'weight',
+          'bias'
+      ]
+    if model_type == 'LLAMA':
+      return [
+          'input_layernorm.weight',
+          'input_layernorm.bias',
+          'self_attention.dense.bias',
+          "attention.dense.bias",
+          'post_attention_layernorm.weight',
+          'post_attention_layernorm.bias',
+          'mlp.dense_4h_to_h.bias',
+          'final_rmsnorm.weight',
+      ]
+
+
+def get_zero_patterns_for_non_sharded(model_type, sequence_parallel):
+  if model_type == 'GPT':
+    patterns = [
+        r"tied_modules.embed.word_embeddings.norm.weight",
+        r"tied_modules.embed.word_embeddings.norm.bias",
+        r"tied_modules.embed.position_embeddings.weight",
+        r"\d+.self_attention.dense.bias",
+        r"\d+.attention.dense.bias",
+        r"\d+.mlp.dense_4h_to_h.bias",
+    ]
+    if not sequence_parallel:
+        patterns = patterns + [
+            r"\d+.input_layernorm.weight",
+            r"\d+.input_layernorm.bias",
+            r"\d+.post_attention_layernorm.weight",
+            r"\d+.post_attention_layernorm.bias",
+            r"\d+.weight",
+            r"\d+.bias",
+    ]
+    return patterns
+  if model_type == 'BLOOM':
+    patterns = [
+        r"tied_modules.embed.word_embeddings.norm.weight",
+        r"tied_modules.embed.word_embeddings.norm.bias",
+        r"\d+.self_attention.dense.bias",
+        r"\d+.attention.dense.bias",
+        r"\d+.mlp.dense_4h_to_h.bias",
+    ]
+    if not sequence_parallel:
+        patterns = patterns + [
+            r"\d+.input_layernorm.weight",
+            r"\d+.input_layernorm.bias",
+            r"\d+.post_attention_layernorm.weight",
+            r"\d+.post_attention_layernorm.bias",
+            r"\d+.weight",
+            r"\d+.bias",
+    ]
+    return patterns
+  if model_type == 'LLAMA':
+    patterns =  [
+        r"tied_modules.embed.word_embeddings.norm.weight",
+        r"tied_modules.embed.word_embeddings.norm.bias",
+        r"\d+.self_attention.dense.bias",
+        r"\d+.attention.dense.bias",
+        r"\d+.mlp.dense_4h_to_h.bias",
+    ]
+    if not sequence_parallel:
+        patterns = patterns + [
+            r"\d+.input_layernorm.weight",
+            r"\d+.input_layernorm.bias",
+            r"\d+.post_attention_layernorm.weight",
+            r"\d+.post_attention_layernorm.bias",
+            r"\d+.final_rmsnorm.weight",
+    ]
+    return patterns
+
+
+
+@dataclass
+class ParamInfo:
+    pp: int
+    tp: int
+    dp: int
+    data: torch.Tensor
+    numel: int
+
+
+def get_zero_pp_stage_non_sharded_params(ds_checkpoint, model_type, sequence_parallel, pp_stage, dp_stage):
+    patterns = get_zero_patterns_for_non_sharded(model_type, sequence_parallel)
+    params = {}
+    for tp_stage in tqdm.tqdm(range(ds_checkpoint.tp_degree), desc='bf16 zero files'):
+        sd = ds_checkpoint.get_zero_checkpoint_state(
+            pp_index=pp_stage,
+            tp_index=tp_stage,
+            dp_index=dp_stage)
+
+        optim_sd = sd["optimizer_state_dict"]
+        param_slice_mappings = optim_sd["param_slice_mappings"]
+        state_groups = optim_sd["base_optimizer_state"]["state"]
+        fp32_groups = optim_sd["single_partition_of_fp32_groups"]
+
+        for param_group_id in range(len(state_groups)):
+            flat_state = dict(
+                exp_avg=state_groups[param_group_id]["exp_avg"],
+                exp_avg_sq=state_groups[param_group_id]["exp_avg_sq"],
+                fp32=fp32_groups[param_group_id],
+            )
+
+            for name, fragment_mapping in param_slice_mappings[param_group_id].items():
+                if not any(re.match(pattern, name) for pattern in patterns):
+                    continue
+
+                for state_key in flat_state.keys():
+                    tensor = flat_state[state_key].narrow(
+                        dim=0,
+                        start=fragment_mapping.start,
+                        length=fragment_mapping.numel).clone()
+                    info = ParamInfo(pp=pp_stage, tp=tp_stage, dp=dp_stage,
+                                     data=tensor, numel=fragment_mapping.numel)
+                    full_name = name + '.__' + state_key
+                    if full_name not in params:
+                        params[full_name] = []
+                    params[full_name].append(info)
+    return params
+
+
+def verify_equal_params(params, tp):
+    failed = 0
+    report = {}
+    for name, info in params.items():
+        n = len(info)
+        if n != tp:
+            ok = False
+            print(f'{name}: FAILED expected n={n} == tp={tp}')
+        elif n == 1:
+            ok = True
+        else:
+            ok = all([(x.numel == info[0].numel) for x in info[1:]])
+            if not ok:
+                print(f'{name}: FAILED numel comparison [n={n}]')
+            else:
+                ok = all([x.data.eq(info[0].data).all().item() for x in info[1:]])
+                if not ok:
+                    print(f'{name}: FAILED data comparison [n={n}]')
+        failed += (ok == False)
+        report[name] = (ok, n)
+        if ok:
+            print(f'{name}: OK [n={n}]')
+    return failed, report
+
+
+def update_layer_non_sharded_params(params, model_type, filename, pp_index, tp_index):
+    layer_id, file_tp_index = re.search('layer_(\d+)-model_(\d+)', filename).groups()
+    layer_id = int(layer_id)
+    file_tp_index = int(file_tp_index)
+    #assert tp_index == file_tp_index, f'Inconsistent tp index tp_index={tp_index} file_tp_index={file_tp_index}'
+    if tp_index != file_tp_index:
+        print('bad')
+
+    sd = torch.load(filename, map_location=torch.device('cpu'))
+    sequential_layers = get_layer_patterns_for_non_sharded(model_type)
+    for key in sd.keys():
+        if key in sequential_layers:
+            param_key = str(layer_id) + '.' + key
+            if param_key not in params:
+                params[param_key] = []
+            info = ParamInfo(pp=pp_index, tp=tp_index, dp=-1,
+                             data=sd[key], numel=sd[key].numel())
+            params[param_key].append(info)
+    return params
+
+
+def verify_layer_files(ds_checkpoint, model_type):
+    src_3d = ds_checkpoint.zero_checkpoint.src_3d
+    dp, tp, pp = src_3d.dp_degree, src_3d.tp_degree, src_3d.pp_degree
+
+    total_failed = 0
+    for pp_index in range(pp):
+        print(f'\nChecking pp_stage={pp_index}')
+        params = {}
+        if pp_index == 0:
+            for tp_index in range(tp):
+                for filename in ds_checkpoint.tp_to_embedding_map[tp_index]:
+                    update_layer_non_sharded_params(params, model_type,
+                                                     filename, pp_index, tp_index)
+        for tp_index in range(tp):
+            for filename_list in ds_checkpoint.transformer_file_map[(tp_index, pp_index)]:
+                for filename in filename_list:
+                    update_layer_non_sharded_params(params, model_type,
+                                                     filename, pp_index, tp_index)
+        if pp_index == (pp-1):
+            for tp_index in range(tp):
+                for filename in ds_checkpoint.tp_to_final_norm_map[tp_index]:
+                    update_layer_non_sharded_params(params, model_type,
+                                                     filename, pp_index, tp_index)
+        failed, report = verify_equal_params(params, tp)
+        total_failed += failed
+    return total_failed
+
+
+def verify_zero_files(ds_checkpoint, model_type,sequence_parallel):
+    src_3d = ds_checkpoint.zero_checkpoint.src_3d
+    dp, tp, pp = src_3d.dp_degree, src_3d.tp_degree, src_3d.pp_degree
+
+    total_failed = 0
+    for i in range(pp):
+        for j in range(dp):
+            print(f'\nChecking pp_stage={i} dp_stage={j}')
+            params = get_zero_pp_stage_non_sharded_params(ds_checkpoint, model_type, sequence_parallel,
+                                                           pp_stage=i, dp_stage=j)
+            failed, report = verify_equal_params(params, tp)
+            total_failed += failed
+    return total_failed
+
+def verify_checkpoint(folder,model_type,sequence_parallel=False):
+    final_layer_norm_idx = -2 if model_type == 'LLAMA' else -1
+    ds_checkpoint = DeepSpeedCheckpoint(folder,final_layer_norm_idx=final_layer_norm_idx)
+    ds_checkpoint.validate_files()
+    show_3d(ds_checkpoint)
+
+    print('\nVerify ** layer_ ** files')
+    total_failed_layer = verify_layer_files(ds_checkpoint, model_type)
+    if total_failed_layer == 0:
+        print('\nCheckpoint layer files OK')
+    else:
+        print(f"\nCheckpoint layer files BAD with total_failed={total_failed_layer}")
+
+    print('\nVerify ** bf16_zero_ ** files')
+    total_failed_zero = verify_zero_files(ds_checkpoint, model_type,sequence_parallel)
+    if total_failed_zero == 0:
+        print('\nCheckpoint zero files OK')
+    else:
+        print(f"\nCheckpoint zero files BAD with total_failed={total_failed_zero}")
+
+    return (total_failed_layer + total_failed_zero) == 0
+
+
+def main():
+    print(f'Verify DeepSpeed Checkpoint consistency for non-TP-sharded parameters')
+    args = parse_arguments()
+    print(args)
+    assert verify_checkpoint(args.folder, args.model_type, args.sequence_parallel) is True, "Checkpoint verification failed"
+
+if __name__ == "__main__":
+    main()

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/tools/create_doc_index.py

@@ -0,0 +1,33 @@
+import os
+import sys
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__),
+                                             os.path.pardir)))
+
+from megatron import print_rank_0
+from megatron.indexer import IndexBuilder
+from megatron.initialize import initialize_megatron
+
+
+def main():
+    """Create a BlockData data structure by running an IndexBuilder over an ICT Dataset
+    - Include all args needed for initial model specification
+
+    Other key args:
+        --block-data-path: path to write to
+        --ict-load or --realm-load: path to checkpoint with which to embed
+        --data-path and --titles-data-path: paths for dataset
+        --indexer-log-interval: reporting interval
+        --indexer-batch-size: size specific for indexer jobs
+
+    Check README.md for example script
+    """
+
+    initialize_megatron(extra_args_provider=None,
+                        args_defaults={'tokenizer_type': 'BertWordPieceLowerCase'})
+    index_builder = IndexBuilder()
+    index_builder.build_and_save_index()
+    print_rank_0("Build and save indices: done!")
+
+if __name__ == "__main__":
+    main()
+

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/tools/generate_samples_gpt.py

@@ -0,0 +1,173 @@
+# coding=utf-8
+# Copyright (c) 2023 Habana Labs, Ltd. an Intel Company.
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Sample Generate GPT"""
+
+import deepspeed
+
+import os
+import sys
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__),
+                                             os.path.pardir)))
+
+from megatron import get_args
+from megatron import print_rank_0
+from megatron import get_tokenizer
+from megatron import mpu
+from megatron.checkpointing import load_checkpoint
+from megatron.initialize import initialize_megatron
+from megatron.model import GPTModel
+from megatron.training import get_model
+from megatron.text_generation_utils import generate_and_write_samples_unconditional
+from megatron.text_generation_utils import generate_samples_input_from_file
+from megatron.text_generation_utils import generate_samples_interactive
+import deepspeed
+import torch
+
+def model_provider(pre_process=True, post_process=True):
+    """Build the model."""
+
+    print_rank_0('building GPT model ...')
+    model = GPTModel(num_tokentypes=0, parallel_output=False,
+                     pre_process=pre_process, post_process=post_process, 
+                     return_moe_loss=False) # we need to set "return_moe_loss" for the inference_mode
+    return model
+
+
+def add_text_generate_args(parser):
+    """Text generation arguments."""
+    group = parser.add_argument_group(title='text generation')
+
+    group.add_argument("--temperature", type=float, default=1.0,
+                       help='Sampling temperature.')
+    group.add_argument("--greedy", action='store_true', default=False,
+                       help='Use greedy sampling.')
+    group.add_argument("--top_p", type=float, default=0.0,
+                       help='Top p sampling.')
+    group.add_argument("--top_k", type=int, default=0,
+                       help='Top k sampling.')
+    group.add_argument("--out-seq-length", type=int, default=1024,
+                       help='Size of the output generated text.')
+    group.add_argument("--sample-input-file", type=str, default=None,
+                       help='Get input from file instead of interactive mode, '
+                       'each line is an input.')
+    group.add_argument("--sample-output-file", type=str, default=None,
+                       help='Output file got from --sample-input-file')
+    group.add_argument("--num-samples", type=int, default=0,
+                       help='Number of samples to generate unconditionally, '
+                       'defaults to 0 and interactive conditional sampling')
+    group.add_argument("--genfile", type=str,
+                       help='Output file when generating unconditionally')
+    group.add_argument("--recompute", action='store_true',
+                       help='During generation recompute all attention '
+                       'instead of using previously computed keys/values.')
+
+    return parser
+
+def print_latency(latency_set, title=""):
+    # 10 warmup queries
+    latency_set = latency_set[10:]
+    count = len(latency_set)
+    if count > 0:
+        latency_set.sort()
+        n50 = (count - 1) * 0.5 + 1
+        n90 = (count - 1) * 0.9 + 1
+        n95 = (count - 1) * 0.95 + 1
+        n99 = (count - 1) * 0.99 + 1
+        n999 = (count - 1) * 0.999 + 1
+
+        avg = sum(latency_set) / count
+        p50 = latency_set[int(n50) - 1]
+        p90 = latency_set[int(n90) - 1]
+        p95 = latency_set[int(n95) - 1]
+        p99 = latency_set[int(n99) - 1]
+        p999 = latency_set[int(n999) - 1]
+
+        print("====== latency stats {0} ======", title)
+        print("\tAvg Latency: {0:8.2f} ms".format(avg * 1000))
+        print("\tP50 Latency: {0:8.2f} ms".format(p50 * 1000))
+        print("\tP90 Latency: {0:8.2f} ms".format(p90 * 1000))
+        print("\tP95 Latency: {0:8.2f} ms".format(p95 * 1000))
+        print("\tP99 Latency: {0:8.2f} ms".format(p99 * 1000))
+        print("\t999 Latency: {0:8.2f} ms".format(p999 * 1000))
+        
+def main():
+    """Main program."""
+    latencies = []
+    model_latencies = []
+    single_token_latency = []
+
+    initialize_megatron(extra_args_provider=add_text_generate_args,
+                        args_defaults={'tokenizer_type': 'GPT2BPETokenizer',
+                                       'no_load_rng': True,
+                                       'no_load_optim': True})
+
+    args = get_args()
+    
+    if args.num_layers_per_virtual_pipeline_stage is not None:
+        print("Interleaved pipeline schedule is not yet supported for text generation.")
+        exit()
+
+    # Set up model and load checkpoint.
+    model = get_model(model_provider)
+
+    if args.load is not None:
+        _ = load_checkpoint(model, None, None)
+
+    assert len(model) == 1, "Above condition should have caught this"
+    model = model[0]
+
+    if args.ds_inference:
+        model = ds_inference(model, args)
+        print('> DeepSpeed Inference engine initialized')
+
+    # Generate samples.
+    if args.num_samples == 0:
+        assert args.micro_batch_size == args.eval_micro_batch_size, \
+            "main (generate_samples_gpt) - Unsupported for split micro batch size"
+        args.micro_batch_size = 1
+        # Next line should be considered once eval_micro_batch_size is supported here
+        args.eval_micro_batch_size = args.micro_batch_size
+        if args.sample_input_file != None:
+            generate_samples_input_from_file(model)
+        else:
+            generate_samples_interactive(model)
+    else:
+        generate_and_write_samples_unconditional(model, latencies, single_token_latency, model_latencies)
+    
+    
+    #if torch.cuda.current_device() == 0:
+    if torch.distributed.get_rank() == 0:
+        print_latency(latencies)
+        print_latency(model_latencies, "model_latencies")
+        print_latency(single_token_latency, "single_token_latency")
+
+
+def ds_inference(model, args):
+    import megatron.model as mm
+    engine = deepspeed.init_inference(model=model,
+                                      mp_size=args.tensor_model_parallel_size, 
+                                      mpu=mpu,
+                                      dtype=torch.half,
+                                      replace_with_kernel_inject=True,
+                                      moe_experts=args.num_experts,
+                                      moe_type=args.mlp_type)
+    
+    return engine.module
+
+if __name__ == "__main__":
+
+    main()

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/tools/merge_mp_partitions.py

@@ -0,0 +1,352 @@
+# coding=utf-8
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Merge model parallel partitions."""
+
+import os
+import re
+import sys
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__),
+                                             os.path.pardir)))
+
+import torch
+
+from megatron import mpu
+from megatron.checkpointing import load_checkpoint, save_checkpoint
+from megatron.checkpointing import ensure_directory_exists
+from megatron.checkpointing import get_checkpoint_name
+from megatron.checkpointing import get_checkpoint_version
+from megatron.checkpointing import get_checkpoint_tracker_filename
+from megatron.global_vars import set_global_variables, get_args
+from megatron.global_vars import rebuild_tokenizer
+
+
+def split_into_partitions(tensor, num_partitions, partition_dim, stride):
+
+    per_partition_size = mpu.utils.divide(tensor.size(partition_dim),
+                                          num_partitions)
+    per_partition_per_stride_size = mpu.utils.divide(per_partition_size, stride)
+
+    partitions_list = torch.split(tensor,
+                                  per_partition_per_stride_size,
+                                  dim=partition_dim)
+
+    partitions = []
+    for i in range(num_partitions):
+        partition = torch.cat(partitions_list[i::num_partitions],
+                              dim=partition_dim)
+        partitions.append(partition)
+
+    return partitions
+
+
+def merge_partitions(merged, partitions, partition_dim, stride):
+
+    # Number and size of each partition.
+    num_partitions = len(partitions)
+    per_partition_size = None
+    for partition in partitions:
+        if per_partition_size is None:
+            per_partition_size = partition.size(partition_dim)
+        else:
+            assert per_partition_size == partition.size(partition_dim)
+
+    def concat_partitions(partitions_):
+        with torch.no_grad():
+            if (per_partition_size * num_partitions) == merged.size(
+                    partition_dim):
+                torch.cat(partitions_, dim=partition_dim, out=merged)
+            else:
+                print('     ***WARNING*** sizes do not match. Will cut '
+                      'the merged partitions by {} along dimension {} '
+                      'to reduce the size from {} to {} ...'.format(
+                          (per_partition_size * num_partitions) - \
+                          merged.size(partition_dim), partition_dim,
+                          per_partition_size * num_partitions,
+                          merged.size(partition_dim)))
+                merged_ = torch.cat(partitions_, dim=partition_dim)
+                merged_split = torch.split(merged_, merged.size(partition_dim),
+                                           dim=partition_dim)
+                merged_ = merged_split[0]
+                assert merged_.size(partition_dim) == merged.size(partition_dim)
+                merged.data.copy_(merged_.data)
+
+    # If stride is 1, then do simple concatination.
+    if stride == 1:
+        concat_partitions(partitions)
+        return
+
+    # For none unity strides, first split based on stride and then group.
+    per_partition_per_stride_size = mpu.utils.divide(per_partition_size, stride)
+    # Chunk and build a list.
+    chunks = None
+    for i, partition in enumerate(partitions):
+        chunk = torch.split(partition,
+                            per_partition_per_stride_size,
+                            dim=partition_dim)
+
+        if chunks is None:
+            chunks = [0]*(num_partitions*len(chunk))
+        chunks[i::num_partitions] = chunk
+
+    # Concatinate.
+    concat_partitions(chunks)
+
+    return
+
+
+def get_model(model_type):
+
+    if model_type == 'BERT':
+        from pretrain_bert import model_provider
+    elif model_type == 'GPT':
+        from pretrain_gpt import model_provider
+    elif model_type == 'RACE':
+        from tasks.race.finetune import model_provider
+    elif model_type == ['MNLI', 'QQP']:
+        num_classes = 2
+        if model_type == 'MNLI':
+            num_classes = 3
+        from megatron.model.classification import Classification
+        def model_provider():
+            return Classification(num_classes=num_classes, num_tokentypes=2)
+    else:
+        raise Exception('unrecognized model type: {}'.format(model_type))
+
+    model = model_provider()
+    model = model.half()
+
+    return model
+
+
+def get_parallel_checkpoint_name(path):
+
+    tracker_filename = get_checkpoint_tracker_filename(path)
+    iteration = 0
+    with open(tracker_filename, 'r') as f:
+        metastring = f.read().strip()
+        iteration = int(metastring)
+    assert iteration > 0
+    checkpoint_name = get_checkpoint_name(path, iteration)
+
+    return checkpoint_name, iteration
+
+
+def test_split_merge():
+
+    print('testing split and merge ...')
+
+    #[QKV.ROW-COL]
+    tensor = torch.FloatTensor([[1.11, 1.12, 1.13, 1.14, 1.15],
+                                [1.21, 1.22, 1.23, 1.24, 1.25],
+                                [1.31, 1.32, 1.33, 1.34, 1.35],
+                                [1.41, 1.42, 1.43, 1.44, 1.45],
+                                [2.11, 2.12, 2.13, 2.14, 2.15],
+                                [2.21, 2.22, 2.23, 2.24, 2.25],
+                                [2.31, 2.32, 2.33, 2.34, 2.35],
+                                [2.41, 2.42, 2.43, 2.44, 2.45],
+                                [3.11, 3.12, 3.13, 3.14, 3.15],
+                                [3.21, 3.22, 3.23, 3.24, 3.25],
+                                [3.31, 3.32, 3.33, 3.34, 3.35],
+                                [3.41, 3.42, 3.43, 3.44, 3.45]])
+
+    num_partitions = 2
+    partition_dim = 0
+    stride = 3
+    partitions = split_into_partitions(tensor, num_partitions,
+                                       partition_dim, stride)
+
+    merged = torch.zeros_like(tensor)
+    merge_partitions(merged, partitions, partition_dim, stride)
+
+    max_error = (merged - tensor).abs().max()
+    print('  > max error (should be zero): {}'.format(max_error))
+
+
+def get_mp_merge_args(parser):
+    """Provide extra arguments required for merging."""
+    group = parser.add_argument_group(title='mp merge')
+
+    group.add_argument('--model-type', type=str, required=True,
+                       choices=['BERT', 'GPT', 'RACE', 'MNLI', 'QQP'],
+                       help='Type of the mdoel.')
+    group.add_argument('--target-pipeline-model-parallel-size', type=int, default=1,
+                       help='Degree of pipeline model parallelism in output model.')
+
+    return parser
+
+
+def main():
+
+    # Arguments do sanity checks on the world size, but we don't care,
+    # so trick it into thinking we are plenty of processes
+    os.environ["WORLD_SIZE"] = f'{2**31}'
+
+    # Args
+    set_global_variables(extra_args_provider=get_mp_merge_args,
+                         args_defaults = {'use_cpu_initialization': True,
+                                          'micro_batch_size': 1,
+                                          'no_load_optim': True,
+                                          'no_load_rng': True,
+                                          'no_save_optim': True,
+                                          'no_save_rng': True,
+                                          'save_interval': 1})
+    args = get_args()
+
+    if args.pipeline_model_parallel_size > 1:
+        print("Checkpoints with pipeline model parallelism are not currently supported.")
+        exit()
+
+    model_type = args.model_type
+    orig_tensor_model_parallel_size = args.tensor_model_parallel_size
+    args.tensor_model_parallel_size = 1
+    tokenizer = rebuild_tokenizer(args)
+
+    print('\n merging model parallel partitions ...')
+    print(' > number of partitions: {}'.format(orig_tensor_model_parallel_size))
+    print(' > checkpoint path: {}'.format(args.load))
+    print(' > model parameters:')
+    print('    number of tokens ................ {} '.format(
+        tokenizer.vocab_size))
+    print('    number of layers ................ {}'.format(args.num_layers))
+    print('    hidden size ..................... {}'.format(args.hidden_size))
+    print('    number of attention heads ....... {}'.format(
+        args.num_attention_heads))
+    print('    maximum position embeddings ..... {}'.format(
+        args.max_position_embeddings))
+
+    # Full model.
+    print('> building the full model ...')
+    mpu.initialize.set_tensor_model_parallel_world_size(1)
+    mpu.initialize.set_tensor_model_parallel_rank(0)
+    mpu.initialize.set_pipeline_model_parallel_world_size(1)
+    mpu.initialize.set_pipeline_model_parallel_rank(0)
+    merged_model = get_model(model_type)
+
+    # Build and load partitions.
+    partitions = []
+    iteration = 0
+    args.tensor_model_parallel_size = orig_tensor_model_parallel_size
+    tokenizer = rebuild_tokenizer(args)
+    mpu.initialize.set_tensor_model_parallel_world_size(args.tensor_model_parallel_size)
+    for rank in range(args.tensor_model_parallel_size):
+        # Reset these since load_checkpoint asserts they are 0, but we are loading
+        # multiple checkpoints in the same process and they get set each time
+        args.consumed_train_samples = 0
+        args.consumed_valid_samples = 0
+
+        mpu.initialize.set_tensor_model_parallel_rank(rank)
+        checkpoint_name, iteration = get_parallel_checkpoint_name(args.load)
+        model_ = get_model(model_type)
+        print(f'> loading {checkpoint_name} ...')
+        load_checkpoint(model_, None, None)
+        print(f'> checkpoint version {get_checkpoint_version()}')
+        partitions.append(model_)
+
+    # Parameter generators so we can loop through them semiltaneouly.
+    merged_params_gen = merged_model.named_parameters()
+    partitions_params_gen = [partition.named_parameters()
+                             for partition in partitions]
+    while True:
+        try:
+
+            # Get the params and check names.
+            name, merged_param = next(merged_params_gen)
+            print(' > working on {} ...'.format(name))
+            print('     merged         type: {}, size: {}'.format(
+                merged_param.dtype, list(merged_param.size())))
+            partitions_param = []
+            for rank, partition_params_gen in enumerate(partitions_params_gen):
+                partition_name, partition_param = next(partition_params_gen)
+                assert partition_name == name
+                partitions_param.append(partition_param)
+                print('     partition {}    type: {}, size: {}'.format(
+                    rank, partition_param.dtype, list(partition_param.size())))
+
+            # For the non-parallel parameters, simply copy the rank 0 values.
+            if not hasattr(merged_param, 'tensor_model_parallel'):
+                print('     none-parallel parameter, simple copy from rank 0')
+                with torch.no_grad():
+                    merged_param.data.copy_(partitions_param[0].data)
+            # For parallel parameters, merge the values
+            else:
+                dim = merged_param.partition_dim
+                stride = merged_param.partition_stride
+                print(f'     parallel parameter merge with stride {stride} along '
+                      f'dimention {dim}')
+                merge_partitions(merged_param,
+                                 partitions_param,
+                                 dim,
+                                 stride)
+
+        except StopIteration:
+            break
+
+    partitions = []
+    args.tensor_model_parallel_size = 1
+    args.pipeline_model_parallel_size = args.target_pipeline_model_parallel_size
+
+    assert args.num_layers % args.pipeline_model_parallel_size == 0, \
+        'num_layers must be divisible by target pipeline model parallel size'
+    layers_per_part = args.num_layers // args.pipeline_model_parallel_size
+
+    tokenizer = rebuild_tokenizer(args)
+    mpu.initialize.set_tensor_model_parallel_world_size(args.tensor_model_parallel_size)
+    mpu.initialize.set_tensor_model_parallel_rank(0)
+    mpu.initialize.set_pipeline_model_parallel_world_size(args.pipeline_model_parallel_size)
+
+    # regex to parse out layer number from param name
+    layer_re = re.compile('layers\.([0-9]+)')
+
+    if args.pipeline_model_parallel_size > 1:
+        merged_params = {}
+        for name, merged_param in merged_model.named_parameters():
+            merged_params[name] = merged_param
+
+        for rank in range(args.pipeline_model_parallel_size):
+            mpu.initialize.set_pipeline_model_parallel_rank(rank)
+            model = get_model(model_type)
+            def update_layer_num(m):
+                # TODO! This assumes no interleaved pipeline execution
+                layer = int(m.group(1))
+                layer += rank * layers_per_part
+                return f'layers.{layer}'
+
+            for dst_name, partition_param in model.named_parameters():
+                if dst_name == "word_embeddings.weight":
+                    # See comment in MegatronModule.initialize_word_embeddings()
+                    src_name = "language_model.embedding.word_embeddings.weight"
+                else:
+                    # Translate destination layer number (0-N for each partition)
+                    # to source layer number (single-model layer number)
+                    src_name = re.sub(layer_re, update_layer_num, dst_name)
+                print(f" > copying {src_name} to {dst_name} in rank {rank}'s model")
+                partition_param.data.copy_(merged_params[src_name].data)
+
+            partitions.append(model)
+    else:
+        partitions = [merged_model]
+
+    for rank, model in enumerate(partitions):
+        mpu.initialize.set_pipeline_model_parallel_rank(rank)
+        print(f"> saving rank {rank}'s model")
+        save_checkpoint(iteration, model, None, None)
+
+    print('done :-)')
+
+
+if __name__ == '__main__':
+
+    main()

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/tools/openwebtext/add_id.py

@@ -0,0 +1,67 @@
+# coding=utf-8
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+import json
+import os
+import time
+
+"""
+This code adds id to each json object in a json file. User can add prefix
+to the ids.
+"""
+
+if __name__ == '__main__':
+
+    print('parsing the arguments ...')
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--input-file', type=str, default=None, help='Input'\
+        ' json file where id needs to be added')
+    parser.add_argument('--output-file', type=str, default=None, help=\
+        'Output file name with id')
+    parser.add_argument('--id-prefix', type=str, default=None, help=\
+        'Id prefix')
+    parser.add_argument('--log-interval', type=int, default=100,
+                       help='Log interval')
+    args = parser.parse_args()
+
+    print('Adding ids to dataset ...')
+
+    f_input = open(args.input_file, 'r', encoding='utf-8')
+    f_output = open(args.output_file, 'wb')
+
+    unique_ids = 1
+    start_time = time.time()
+    for row in f_input:
+        each_row = json.loads(row)
+        adlr_id_string = args.id_prefix + '-{:010d}'.format(int(unique_ids))
+        each_row['adlr_id'] = adlr_id_string
+        myjson = json.dumps(each_row, ensure_ascii=False)
+
+        f_output.write(myjson.encode('utf-8'))
+        f_output.write('\n'.encode('utf-8'))
+
+        if unique_ids % args.log_interval == 0:
+            print('    processed {:9d} documents in {:.2f} seconds ...'.format( \
+                    unique_ids, time.time() - start_time), flush=True)
+
+        unique_ids += 1
+
+    # Close the file.
+    f_input.close()
+    f_output.close()
+    
+    print('done :-)', flush=True)

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/tools/openwebtext/cleanup_dataset.py

@@ -0,0 +1,115 @@
+# coding=utf-8
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import ftfy
+import json
+from langdetect import detect
+import numpy as np
+import time
+import os
+import sys
+
+from tokenizer import Tokenizer
+
+MIN_DOCUMENT_LENGHT = 128
+
+
+def print_progress(prefix, start_time, num_docs, num_fixed_text,
+                   num_non_english_docs, chars_non_english_docs,
+                   num_small_docs, chars_small_docs):
+
+    string = prefix + ' | '
+    string += 'elapsed time: {:.2f} | '.format(time.time() - start_time)
+    string += 'documents: {} | '.format(num_docs)
+    string += 'fixed text: {} | '.format(num_fixed_text)
+    string += 'non-english: {} | '.format(num_non_english_docs)
+    string += 'non-english chars: {} | '.format(chars_non_english_docs)
+    string += 'small docs: {} | '.format(num_small_docs)
+    string += 'small docs chars: {}'.format(chars_small_docs)
+    print(string, flush=True)
+
+
+def filter_corpus(filename, out_filename, print_interval=10000):
+
+    print(' > filtering {}'.format(filename))
+
+    tokenizer = Tokenizer(cache_dir='./cache')
+
+    num_docs = 0
+    num_written_docs = 0
+    num_small_docs = 0
+    num_fixed_text = 0
+    num_non_english_docs = 0
+    chars_non_english_docs = 0
+    chars_small_docs = 0
+    start_time = time.time()
+    with open(out_filename, 'wb') as f:
+        with open(filename, 'r') as fin:
+            for line in fin:
+                try:
+                    num_docs += 1
+                    myjson = json.loads(line)
+                    # Fix text
+                    text = ftfy.fix_text(myjson['text'])
+                    if text != myjson['text']:
+                        num_fixed_text += 1
+                    myjson['text'] = text
+                    # Detect language.
+                    if detect(text) != 'en':
+                        print('[non-english text]', myjson)
+                        num_non_english_docs += 1
+                        chars_non_english_docs += len(text)
+                        continue
+                    # On average each token is 5 characters so 8 is an
+                    # upper bound.
+                    if len(text) < (8 * MIN_DOCUMENT_LENGHT):
+                        tokens = tokenizer.tokenize_document(text)
+                        if len(tokens) < MIN_DOCUMENT_LENGHT:
+                            print('[small document, skipping]:', myjson)
+                            num_small_docs += 1
+                            chars_small_docs += len(text)
+                            continue
+                    myjson = json.dumps(myjson, ensure_ascii=False)
+                    f.write(myjson.encode('utf-8'))
+                    f.write('\n'.encode('utf-8'))
+                    num_written_docs += 1
+                    if num_docs % print_interval == 0:
+                        print_progress('[PROGRESS]', start_time, num_docs,
+                                       num_fixed_text, num_non_english_docs,
+                                       chars_non_english_docs,
+                                       num_small_docs, chars_small_docs)
+                except Exception as e:
+                    print('    skipping ', line, e)
+
+    print_progress('[FINAL]', start_time, num_docs,
+                   num_fixed_text, num_non_english_docs,
+                   chars_non_english_docs,
+                   num_small_docs, chars_small_docs)
+
+
+if __name__ == '__main__':
+
+    print('building gpt2 dataset ...')
+
+    input_filename = sys.argv[1]
+    output_filename = sys.argv[2]
+
+    print('will be reading {}'.format(input_filename))
+    print('and will write the results to {}'.format(output_filename))
+
+    filter_corpus(input_filename, output_filename)
+
+

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/tools/openwebtext/filter_ngrams.py

@@ -0,0 +1,492 @@
+# coding=utf-8
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Deduplicate downstream tasks from training dataset. 13-grams have been used.
+All split documents with less than 200 characters got filtered. Any document
+with more than 10 splits got filtered as well.
+"""
+
+import argparse
+from functools import partial
+import json
+import multiprocessing
+import nltk
+import pickle
+import re
+import string
+import sys
+import time
+
+def get_words(text):
+    # get all the lowercase words from text
+    words, positions = [], []
+    for match in re.finditer(r'\w+', text.lower()):
+        words.append(match.group(0))
+        positions.append(match.start())
+    return words, positions
+
+# splits the text
+def split_text(text, start_position, remove_char_each_side, seq):
+    # first part of the text
+    punctuations = ".!?"
+    pos = start_position - remove_char_each_side
+    text_first = ""
+    while pos > 0 and not text[pos] in punctuations:
+        pos -= 1
+    if pos > 0:
+        text_first = text[0:pos+1]
+
+    # add length of seq and remove_char_each_side
+    pos = start_position + len(seq) + remove_char_each_side
+
+    # last part of the text
+    text_second = ""
+    while pos < len(text) and not text[pos] in punctuations:
+        pos += 1
+    if pos + 1 < len(text):
+        text_second = text[pos+1:len(text)]
+
+    return text_first, text_second
+
+def check_and_clean_text(args, words, ngrams, text, start_position, \
+    text_buf_ngram_free, text_buf, local_ngram):
+
+    seq = " ".join(words)
+    if seq in ngrams:
+        print(" [matched]: {}".format(seq), flush=True)
+
+        if args.get_ngram_freq_only:
+            # increase freq of this seq and then only consider the later part
+            # of the text for further processing
+            if seq in local_ngram:
+                local_ngram[seq] += 1
+            else:
+                local_ngram[seq] = 1
+            #print(" [increased]: {} {}".format(seq, ngrams[seq]), flush=True)
+            if (start_position + len(seq) + 1) < len(text):
+                text_buf.append(text[start_position + len(seq) + 1:len(text)])
+            return False            
+
+        # split the text
+        text_first, text_second = split_text(text, start_position, \
+            args.remove_char_each_side, seq)
+
+        # first part of ngrams free
+        if len(text_first) > args.filter_text_char_len:
+            text_buf_ngram_free.append(text_first)
+
+        # add second part for further processing
+        if len(text_second) > args.filter_text_char_len:
+            text_buf.append(text_second)
+
+        return False # not ngram free
+
+    # ngram free
+    return True
+
+
+def free_ngram(line, args, key, ngrams, ngrams_freq_sorted):
+    # remove all the ngrams
+
+    try:
+        myjson = json.loads(line)
+        text_buf = [myjson[key]]
+    except Exception as e:
+        print("Error: {}".format(e), flush=True)
+        text_buf = []
+
+    text_buf_ngram_free = []
+    local_ngram = {}
+    while len(text_buf) > 0:
+
+        # get the first one from the buffer
+        text = text_buf.pop(0)
+        words, positions = get_words(text)
+        
+        ngram_free = True
+        # find each max n-grams and check dictionary
+        for i in range(len(words) - args.max_ngram_size + 1):
+            check_ngram_free = check_and_clean_text(args, words[i:\
+                i+args.max_ngram_size], ngrams, text, positions[i], \
+                text_buf_ngram_free, text_buf, local_ngram)
+
+            # the seq is ngram free? if yes, break
+            if not check_ngram_free:
+                ngram_free = False
+                break
+
+            # if max ngrams doesn't match, check if any other lower n-grams
+            # within max ngram macthes
+            for ngram_len, _ in ngrams_freq_sorted:
+                check_ngram_free = check_and_clean_text(args, words[i:\
+                    i+ngram_len], ngrams, text, positions[i], \
+                    text_buf_ngram_free, text_buf, local_ngram)
+
+                # same check as above
+                if not check_ngram_free:
+                    ngram_free = False
+                    break
+
+            # check break from lower than max ngram loop above
+            if not ngram_free:
+                break
+
+        # for the last max n-gram, check all the lower ngrams in it
+        if ngram_free and len(words) - args.max_ngram_size > 0:
+            # get the last words of the lax max ngram
+            last_seq_words = words[(len(words)-args.max_ngram_size):len(words)]
+            last_seq_start_position = len(words) - args.max_ngram_size
+
+            # check all n-grams lower than the max
+            for pos, (ngram_len, _) in enumerate(ngrams_freq_sorted):
+
+                # ignore the max ngram as has been considered already
+                if ngram_len == args.max_ngram_size:
+                    continue
+
+                # find each ngram of ngram_len in max n-grams and check
+                for i in range(len(last_seq_words) - ngram_len + 1):
+                    check_ngram_free = check_and_clean_text(args, \
+                        last_seq_words[i:i+ngram_len], ngrams, text,\
+                        positions[last_seq_start_position+i], \
+                        text_buf_ngram_free, text_buf, local_ngram)
+
+                    if not check_ngram_free:
+                        ngram_free = False
+                        break
+
+                if not ngram_free:
+                    break
+
+        # texts are ngram free
+        if ngram_free and not args.get_ngram_freq_only:
+            text_buf_ngram_free.append(text)
+
+    # check if the text has only been trimmed
+    trimmed = 0
+    if not args.get_ngram_freq_only and len(text_buf_ngram_free) == 1 and \
+        len(text_buf_ngram_free[0]) < len(myjson[key]):
+        trimmed = 1
+
+    return text_buf_ngram_free, trimmed, myjson, local_ngram
+
+# insert word sequence into dictionary
+def insert_dict(words, ngrams, pos):
+    seq = " ".join(words)
+    if seq not in ngrams:
+        ngrams[seq] = 0
+        #ngrams[seq] = pos
+
+# insert each ngram from text into the ngrams dictionary
+def compute_ngrams_insert_dict(args, text, ngrams):
+    words, positions = get_words(text)
+    if len(words) < args.min_ngram_size:
+        return
+
+    if len(words) < args.max_ngram_size:
+        insert_dict(words, ngrams, positions[0])
+
+    for i in range(len(words) - args.max_ngram_size+1):
+        insert_dict(words[i:i+args.max_ngram_size], ngrams, positions[i])
+
+
+# Build ngrams for the lambada dataset
+def process_task_lambda(args, task_file, ngrams):
+    print(' reading from {} and computing ngrams'.format(task_file))
+    with open(task_file, 'r') as f:
+        for line in f:
+            try:
+                myjson = json.loads(line)
+                text = myjson['text']
+                compute_ngrams_insert_dict(args, text, ngrams)
+            except Exception as e:
+                print('Error:', e)
+    print(" Entities in ngrams {}".format(len(ngrams)), flush=True)
+
+
+# Build ngrams for the dataset of the given task
+def process_task(args, task_name, ngrams):
+
+    print(' reading from {} and computing ngrams'.format('import datasets'))
+    print(" Current entities in ngrams {}".format(len(ngrams)), flush=True)
+    # using validation/test data from datasets
+    from datasets import load_dataset
+
+    entities_in_ngrams = len(ngrams)
+
+    # load the dataset
+    if task_name == 'squad':
+        dataset = load_dataset('squad_v2', split='validation')
+    elif task_name == 'natural_questions':
+        dataset = load_dataset('natural_questions', split='validation')
+    elif task_name == 'triviaqa':
+        dataset = load_dataset('trivia_qa', 'unfiltered', split='test')
+    elif task_name == 'webqa':
+        dataset = load_dataset('web_questions', split='test')
+    elif task_name == 'race':
+        dataset = load_dataset('race', 'all', split='test')
+    elif task_name == 'drop':
+        dataset = load_dataset('drop', split='validation')
+    elif task_name == 'coqa':
+        dataset = load_dataset('coqa', split='validation')
+    elif task_name == 'piqa':
+        dataset = load_dataset('piqa', split='test')
+    else:
+        print("Invalid task name: {}".format(task_name), flush=True)
+        return
+
+    # read the dataset and add to ngrams
+    for line in dataset:
+        try:
+            if task_name in ['squad', 'triviaqa', 'webqa', 'race', 'drop']:
+                text = line['question']
+                compute_ngrams_insert_dict(args, text, ngrams)
+            elif task_name == 'natural_questions':
+                text = line['question']['text']
+                compute_ngrams_insert_dict(args, text, ngrams)
+            elif task_name == 'coqa':
+                all_questions = line['questions']
+                for question in all_questions:
+                    compute_ngrams_insert_dict(args, question, ngrams)
+            elif task_name == 'piqa':
+                text = line['goal']
+                compute_ngrams_insert_dict(args, text, ngrams)
+        except Exception as e:
+            print('Error:', e)
+
+    print(" After task {} entities in ngrams {}, added {}".format(task_name, \
+            len(ngrams), len(ngrams) - entities_in_ngrams), flush=True)
+
+def compute_tasks_ngrams(args, ngrams):
+    start_time = time.time()
+    for _, task_name in enumerate(args.tasks):
+        print('Task: {}'.format(task_name), flush=True)
+        if task_name == 'lambada':
+            assert args.lambada_path is not None
+            process_task_lambda(args, args.lambada_path, ngrams)
+        else:
+            process_task(args, task_name, ngrams)
+    print(" Taken time to compute ngrams {:.2f}".format(time.time() - \
+        start_time), flush=True)
+
+def compute_ngram_freq_sorted(args, ngrams):
+    ngrams_freq = {}
+    for ngram_key in ngrams.keys():
+        length = len(ngram_key.split())
+        ngrams_freq[length] = ngrams_freq[length] + 1 if length in \
+            ngrams_freq else 1
+
+    ngrams_freq_sorted = sorted(ngrams_freq.items(), key=lambda item: item[0])
+    print(" Ngram frequencies: {}".format(ngrams_freq_sorted), flush=True)
+    print(" Entities in ngrams {} min_ngram_size {} max_ngram_size {}".format(\
+            len(ngrams), ngrams_freq_sorted[0][0], ngrams_freq_sorted[len(\
+            ngrams_freq_sorted) -1 ][0]), flush=True)
+    return ngrams_freq_sorted
+
+def get_ngrams_below_threshold(args, ngrams, ngrams_below_threshold, \
+    dedup_file, dedup_key, ngrams_freq_sorted):
+
+    start_time = time.time()
+    # get the ngrams frequency
+    args.get_ngram_freq_only = True
+ 
+    # Open the large file to process in parallel
+    num_workers = args.num_threads 
+    pool = multiprocessing.Pool(num_workers)
+    fin = open(dedup_file, 'r', encoding='utf-8')
+    free_ngram_abt_partial=partial(free_ngram, args=args, key=dedup_key, \
+        ngrams=ngrams, ngrams_freq_sorted=ngrams_freq_sorted)
+    free_ngrams_abt = pool.imap(free_ngram_abt_partial, fin, 500)
+ 
+    counter = 0
+    for _, _, _, local_ngram in free_ngrams_abt:
+        counter += 1
+        if counter % 1000 == 0:
+            print(' [compute_stat]> processed {} documents in {:.2f} seconds ...'.
+                    format(counter, time.time() - start_time), flush=True)
+        for local_key in local_ngram:
+            if local_key in ngrams:
+                ngrams[local_key] += 1
+        local_ngram = {}
+
+    print(' Time taken to compute statistics {:.2f} seconds'.format(time.time() - \
+        start_time), flush=True)
+    pool.close()
+    pool.join()
+
+    start_time = time.time()
+    counter_threshold = 0
+    # Get ngram below theadhold
+    for local_key, local_val in ngrams.items():
+        if ngrams[local_key] < args.key_threshold:
+            print(" [threshold] {} {}".format(local_key, local_val), flush=True)
+            counter_threshold += 1
+            ngrams_below_threshold[local_key] = 1
+            
+    print(' Ngrams below threshold {}'.format(counter_threshold), flush=True)
+    fin.close()
+
+def clean_ngrams_below_threshold(args, ngrams_below_threshold, dedup_file, \
+    dedup_key):
+
+    start_time = time.time()
+    # Now actually filter the dataset
+    args.get_ngram_freq_only = False
+    #id_prefix = '-'.join(args.tasks[::2])
+    id_prefix = '-'.join(args.tasks[::1])
+
+    # get the range of the size of the ngrams
+    ngrams_freq_sorted = compute_ngram_freq_sorted(args, ngrams_below_threshold)
+
+    # Open the large file to process in parallel
+    counter = splitted = ignored = split_mt_thld = trimmed_count = 0
+    num_workers = args.num_threads
+    pool = multiprocessing.Pool(num_workers)
+    fin = open(dedup_file, 'r', encoding='utf-8')
+    free_ngram_clean_partial=partial(free_ngram, args=args, key=dedup_key, \
+        ngrams=ngrams_below_threshold, ngrams_freq_sorted=ngrams_freq_sorted)
+    free_ngrams_clean = pool.imap(free_ngram_clean_partial, fin, 500)
+ 
+    out_f = open(args.output, 'wb')
+
+    for text_buf_ngram_free, trimmed, myjson, _ in free_ngrams_clean:
+        counter += 1
+        try:
+
+            trimmed_count += trimmed
+
+            if len(text_buf_ngram_free) > 1:
+                splitted += 1
+            if len(text_buf_ngram_free) == 0:
+                ignored += 1
+            # more than 10 splits ignored
+            if len(text_buf_ngram_free) > args.splits_count:
+                text_buf_ngram_free = []
+                split_mt_thld += 1
+
+            if args.output is not None:
+                if "split_id" in myjson:
+                    use_prefix = myjson["split_id"] + "-"
+                else:
+                    use_prefix = ""
+
+                for i in range(len(text_buf_ngram_free)):
+                    split_id_string = id_prefix + '-{:010d}'.format(int(\
+                        counter)) + '-{:04d}'.format(int(i))
+                    myjson[dedup_key] = text_buf_ngram_free[i]
+                    myjson["split_id"] = use_prefix + split_id_string
+                    outjson = json.dumps(myjson, ensure_ascii=False)
+                    #outjson = json.dumps({"text":text_buf_ngram_free[i],
+                    #    id_prefix+"_split_id":split_id_string},
+                    #    ensure_ascii=False)
+                    out_f.write(outjson.encode('utf-8'))
+                    out_f.write('\n'.encode('utf-8'))
+
+            if counter % 1000 == 0:
+                print(' [final]> processed {} documents in {:.2f} seconds ...'.
+                    format(counter, time.time() - start_time), flush=True)
+        except Exception as e:
+            print('Error:', e)
+
+    print(' [final]> processed {} documents in {:.2f} seconds ...'.
+        format(counter, time.time() - start_time), flush=True)
+    
+    print(' Total docs {} splitted {} ignored {} splits > theshold {} trimmed'\
+        ' {}'.format(counter, splitted, ignored, split_mt_thld, trimmed_count)\
+        , flush=True)
+
+    pool.close()
+    pool.join()
+
+    out_f.close()
+    fin.close()
+
+if __name__ == '__main__':
+
+    # we use 13-grams, any text less than 200 characters got removed
+    # any text splitted more than 10 got removed as well
+
+    print('parsing the arguments ...')
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--tasks', nargs = '*', required=True, default=None, \
+                        help = 'Tasks to use for deduplication: currently '
+                        ' suuport [lambada, squad, natural_questions,'
+                        ' triviaqa, webqa, race, drop, coqa, and piqa]')
+    parser.add_argument('--lambada-path', type=str, default=None,
+                       help='Only Lambada task needs the path')
+    parser.add_argument('--dedup-dataset', nargs = '*', default=None,
+                       help='Dataset to deduplicate with the key to use'
+                        ' e.g. cc.json text')
+    parser.add_argument('--output', type=str, default=None,
+                       help='Output file name to save dedup dataset')
+    parser.add_argument('--num-threads', type=int, default=40,
+                       help='Number of threads to use')
+    # Default dedup values
+    parser.add_argument('--max-ngram-size', type=int, default=13,
+                       help='Maximum size of ngram to use.')
+    parser.add_argument('--min-ngram-size', type=int, default=8,
+                       help='Minimum size of ngram to use.')
+    parser.add_argument('--filter-text-char-len', type=int, default=200,
+                       help='Remove any text below this length.')
+    parser.add_argument('--key-threshold', type=int, default=10,
+                       help='Number of keys to consider as threshold')
+    parser.add_argument('--save-dictionary', type=str, default=None,
+                       help='Save the dictionary')
+    parser.add_argument('--load-dictionary', type=str, default=None,
+                       help='Load the dictionary')
+    parser.add_argument('--splits-count', type=int, default=10,
+                       help='Remove any documents more than this many splits')
+    parser.add_argument('--remove-char-each-side', type=int, default=200,
+                       help='Maximum size of ngram to use.')
+
+    args = parser.parse_args()
+
+    assert len(args.dedup_dataset) == 2
+    dedup_file = args.dedup_dataset[0]
+    dedup_key = args.dedup_dataset[1]
+
+    # Setup multi-processing
+    num_workers = args.num_threads
+    if args.load_dictionary is None:
+
+        # Build ngrams
+        ngrams = {}
+        compute_tasks_ngrams(args, ngrams)
+
+        # get the range of the size of the ngrams
+        ngrams_freq_sorted = compute_ngram_freq_sorted(args, ngrams)
+
+        # get ngram freq from large file in parallel
+        # get ngrams below threshold
+        ngrams_below_threshold = {}
+        get_ngrams_below_threshold(args, ngrams, ngrams_below_threshold, \
+            dedup_file, dedup_key, ngrams_freq_sorted)
+
+        # save the dictionary if needed
+        if args.save_dictionary is not None:
+            with open(args.save_dictionary, 'wb') as save_dict_handle:
+                pickle.dump(ngrams_below_threshold, save_dict_handle)
+    else:
+        with open(args.load_dictionary, 'rb') as load_dict_handle:
+            ngrams_below_threshold = pickle.load(load_dict_handle)
+
+    # filter the large file
+    if args.output is not None:
+        clean_ngrams_below_threshold(args, ngrams_below_threshold, \
+            dedup_file, dedup_key)
+
+    print('done :-)')

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/gpt3/tools/openwebtext/merge_jsons.py

@@ -0,0 +1,55 @@
+# coding=utf-8
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import glob
+import sys
+import json
+import argparse
+
+if __name__ == '__main__':
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--json_path", type=str, default=".",
+        help="path where all the json files are located")
+
+    parser.add_argument("--output_file", type=str, default="merged_output.json",
+        help="filename where the merged json should go")
+
+    args = parser.parse_args()
+
+    json_path = args.json_path
+    out_file = args.output_file
+
+    json_files = glob.glob(json_path + '/*.json')
+
+    counter = 0
+
+    with open(out_file, 'w') as outfile:
+        for fname in json_files:
+            counter += 1
+
+            if counter % 1024 == 0:
+                print("Merging at ", counter, flush=True)
+
+            with open(fname, 'r') as infile:
+                for row in infile:
+                    each_row = json.loads(row)
+                    outfile.write(row)
+
+
+    print("Merged file", out_file, flush=True)
+
+

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/implementations/HLS-Gaudi2-PT/PyTorch/model/__init__.py

@@ -0,0 +1 @@
+from .resnet import *

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/implementations/HLS-Gaudi2-PT/PyTorch/model/utils.py

@@ -0,0 +1,4 @@
+try:
+    from torch.hub import load_state_dict_from_url
+except ImportError:
+    from torch.utils.model_zoo import load_url as load_state_dict_from_url

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/implementations/HLS-Gaudi2-TF/batch_256.cfg

@@ -0,0 +1,39 @@
+#!/bin/bash
+
+#general param
+export RESNET_SIZE=50
+export IMAGENET_DIR=/root/datasets/imagenet/tf_records
+export TRAIN_STEPS=999
+export DISPLAY_STEPS=90000
+export STEPS_PER_LOOP=90000
+export USE_LARS_OPTIMIZER=1
+export CPU_BIND_TYPE=cpu
+export EPOCHS_BETWEEN_EVALS=4
+export USE_MLPERF=1
+export NO_EVAL=0
+export TF_BF16_CONVERSION=1
+export USE_HOROVOD=1
+export DATASET_CACHE=true
+export SYNTHETIC_DATA=false
+export MODELING=false
+export NUM_TRAIN_FILES=1024
+export NUM_EVAL_FILES=256
+export HOROVOD_FUSION_THRESHOLD=0
+export NUM_WORKERS_PER_HLS=8
+export HLS_TYPE=HLS2
+
+#hp param
+export NUM_WORKERS=8
+export BATCH_SIZE=256
+export TRAIN_EPOCHS=35
+export LARS_DECAY_EPOCHS=36
+export EVAL_OFFSET_EPOCHS=3
+export WARMUP_EPOCHS=3
+export BASE_LEARNING_RATE=9
+export WEIGHT_DECAY=0.00005
+export LR_MOMENTUM=0.9
+export LABEL_SMOOTH=0.1
+export STOP_THRESHOLD=0.759
+
+unset MPI_TCP_INCLUDE
+unset TRAIN_AND_EVAL

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/implementations/HLS-Gaudi2-TF/launch_keras_resnet_hvd.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+cd $SCRIPT_DIR/..
+../scripts/launch_keras_resnet_hvd.sh "$@"

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/implementations/HLS-Gaudi2-TF/list_affinity_topology_bare_metal.sh

@@ -0,0 +1,149 @@
+#!/bin/bash
+
+#Description
+#This script outputs a file for each moduleID.
+#These files contain the Hthread_sequence on which the process is bound too (this is a restriction and not a reservation).
+#We do this by getting the mapping of (ModuleID, pcie_bus_id) from hl-smi
+#Then we map the 2 tuple to a numa by opening the file
+#/sys/bus/pci/devices/<pcie_bus_id >/numa_node
+#Now we have a 3 tuple (ModuleID, pcie_bus_id,  numa_node)
+#Lastly we get the Hthread_sequence that correspond to that numa_node from lscpu so now we have
+#(ModuleID, pcie_bus_id,  numa_node, Hthread_sequence )
+#The Hthread_sequence is then used to bind the process to the specific threads on the numa closest to the PCIE bus.
+
+affinity_print()
+{
+   echo "Affinity: "$1
+}
+
+hl_smi_check()
+{
+   if [[ ! -x `which hl-smi` ]];
+   then
+         affinity_print "hl-smi could not be found, exiting"
+         exit 1
+   fi
+}
+
+check_env()
+{
+   if [[ -z "$NUMA_MAPPING_DIR" ]];
+   then
+         affinity_print "Missing env variable \"NUMA_MAPPING_DIR\", exiting!"
+         exit 1
+   fi
+}
+
+create_temp_files()
+{
+   # create a temp directory, mktemp is used to create a temp directory with a unique name
+   temp_dir=$(mktemp -d)
+
+   # create temp files for holding outputs
+   file_hl_smi=$temp_dir/hl_smi.txt
+   file_module_id=$temp_dir/module_id.txt
+   file_pcie_bus_id=$temp_dir/pcie_bus_id.txt
+   file_pcie_numa=$temp_dir/pcie_numa.txt
+   file_hl_smi=$temp_dir/hl_smi.txt
+   file_configuration_table=$temp_dir/configuration_table.txt
+   file_final_output=$NUMA_MAPPING_DIR/.habana_module_topo
+}
+
+create_configuartion_table()
+{
+   # save the entire hl-smi output to file
+   hl-smi -L > $file_hl_smi
+
+   #check that the driver is up
+   if [ $? -eq 1 ]; then
+      affinity_print "Issue while trying to run hl-smi, aborting..."
+      exit 1
+   fi
+
+   # get the module IDs (unique identifier for each gaudi)
+   grep "Module ID" $file_hl_smi > $file_module_id
+
+   # get the bus IDs
+   grep "Bus Id" $file_hl_smi > $file_pcie_bus_id
+
+   # Get the numa for each PCIE bus
+   for i in `cat $file_pcie_bus_id|awk '{print $4}'`; do
+      numa_node=`cat /sys/bus/pci/devices/$i/numa_node`
+      if [ $numa_node -ge 0 ]; then
+         echo $numa_node >> $file_pcie_numa
+      else
+         for i in `hl-smi -L|grep "Bus Id"|awk '{print $4}'`; do affinity_print "PCIE:"$i", NUMA:"`cat /sys/bus/pci/devices/$i/numa_node`; done
+         affinity_print "Numa mapping isn't set properly, you are most likley running on an unsupported VM, aborting..."
+         exit 1
+      fi
+   done
+
+   #append output files horizontally
+   paste $file_module_id $file_pcie_bus_id $file_pcie_numa | awk ' {print $4,$8,$9}' | sort -k1 > $file_configuration_table
+}
+
+
+create_thread_list()
+{
+   no_of_numa_nodes=`lscpu|grep "NUMA node(s):"|awk '{print $3}'`
+   no_of_gaudis=`cat $file_configuration_table|wc -l`
+   no_of_used_numa=`cat $file_pcie_numa | uniq | wc -l`
+
+
+   for module_id in $(seq 0 $(($no_of_gaudis-1))); do
+      #grab one pcieid at a time (busID)
+      pcie_bus_id=`cat $file_configuration_table | awk '{print $2}' | sed -n $(($module_id+1))p`
+
+      #get the corespoinding numanode (pcie_numa)
+      numa_node=`cat /sys/bus/pci/devices/$pcie_bus_id/numa_node`
+
+      #special barcelona configuration where two sockets are configured to be 4 virtual numa nodes
+      if [[ $no_of_used_numa -eq 2 && $no_of_numa_nodes -eq 4 ]]; then
+         #get current node (moduleID)
+         curr_node=`cat $file_configuration_table | awk '{print ","$3,$1}'| grep ",$numa_node" | awk '{print $2}'|head -1`
+         if [ $module_id -eq $curr_node ]; then
+            numa_node=$(($numa_node-1))
+         fi
+      fi
+
+      #get the list of threads
+      if [ $numa_node -ge 0 ]; then
+         vector=`lscpu --parse | grep ",$numa_node,,"|awk -F"," '{print $1}'`
+         vector=`echo $vector | tr ' ' ,`
+         echo $vector > $NUMA_MAPPING_DIR/.habana_moduleID$module_id
+         echo $vector >> $temp_dir/.module
+      fi
+   done
+}
+
+
+add_thread_list_to_config_table()
+{
+   #put it all together
+   echo "ModID   BusID  NUMA   CPUs: " > $file_final_output
+   echo "=====   =====  =====  ===== " >> $file_final_output
+   paste $file_configuration_table $temp_dir/.module >> $file_final_output
+}
+
+clean_up()
+{
+   #remove the temp dir
+   if [ ! -z "$temp_dir" ]; then
+      rm -fr $temp_dir
+   fi
+}
+
+main()
+{
+   check_env
+   hl_smi_check
+   create_temp_files
+   create_configuartion_table
+   create_thread_list
+   add_thread_list_to_config_table
+   clean_up
+   affinity_print "Script finished successfully"
+   exit 0
+}
+
+main

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/implementations/TensorFlow/common/debug.py

@@ -0,0 +1,107 @@
+# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+###############################################################################
+# Copyright (C) 2020-2021 Habana Labs, Ltd. an Intel Company
+###############################################################################
+
+from absl import flags
+from absl import logging
+from tensorflow.core.protobuf import debug_event_pb2
+from tensorflow.python.debug.lib import debug_events_writer
+from tensorflow.python.framework import op_callbacks
+from tensorflow.python.ops import gen_debug_ops
+import tensorflow as tf
+import re
+import json
+
+flags.DEFINE_string(name='dump_config', default=None, help='Defines config for tensor dumping')
+
+
+class _DumpCallback(object):
+    def __init__(self, dump_root, tensor_debug_mode, circular_buffer_size, op_regex):
+        self._dump_root = dump_root
+        self._tensor_debug_mode = debug_event_pb2.TensorDebugMode.Value(tensor_debug_mode)
+        self._circular_buffer_size = circular_buffer_size
+        self._op_regex = re.compile(op_regex) if isinstance(op_regex, str) else op_regex
+        self._tfdbg_run_id = ''
+        self._dump_op_counter = 0
+
+        debug_writer_args = {
+            "dump_root" : self._dump_root,
+            "circular_buffer_size": self._circular_buffer_size
+        }
+
+        if tf.__version__.startswith("2.4"):
+            debug_writer_args["tfdbg_run_id"] = self._tfdbg_run_id
+
+        self._writer = debug_events_writer.DebugEventsWriter(**debug_writer_args)
+
+    def callback(self, op_type, inputs, attrs, outputs, op_name=None, graph=None):
+        if op_name is not None and self._op_regex.match(op_name):
+            graph_name = "missing-graph-name"
+            if graph is not None and hasattr(graph, "name"):
+                graph_name=graph.name
+
+            logging.info("Adding dump op for '%s' of type '%s' from graph '%s'" %(op_name, op_type, graph_name))
+
+            new_outputs = []
+
+            for output_slot, output in enumerate(outputs):
+                debug_identity_op_kwargs = {
+                    "tfdbg_context_id": graph_name,
+                    "op_name": op_name,
+                    "output_slot": output_slot,
+                    "tensor_debug_mode": self._tensor_debug_mode,
+                    "debug_urls": ["file://%s" % self._dump_root],
+                    "name": "dump_%d" % self._dump_op_counter
+                }
+
+                if tf.__version__.startswith("2.4"):
+                    debug_identity_op_kwargs["circular_buffer_size"] = self._circular_buffer_size
+                    debug_identity_op_kwargs["tfdbg_run_id"] = self._tfdbg_run_id
+
+                self._dump_op_counter = self._dump_op_counter + 1
+                new_outputs.append(gen_debug_ops.debug_identity_v2(output, **debug_identity_op_kwargs))
+
+            return new_outputs
+        else:
+            return None
+
+    def __enter__(self, *args, **kwargs):
+        op_callbacks.add_op_callback(self.callback)
+        logging.info("Enabled tensor dumping")
+
+    def __exit__(self, *args, **kwargs):
+        op_callbacks.remove_op_callback(self.callback)
+        logging.info("Disabled tensor dumping")
+
+    def __del__(self):
+        self._writer.Close()
+
+class _Dummy(object):
+    def __enter__(self, *args, **kwargs):
+        pass
+    def __exit__(self, *args, **kwargs):
+        pass
+
+def dump_callback(config_file=None):
+    if config_file is not None:
+        kwargs = json.load(open(config_file, 'r'))
+        return _DumpCallback(**kwargs)
+    try:
+        kwargs = json.load(open(flags.FLAGS.dump_config, 'r'))
+        return _DumpCallback(**kwargs)
+    except:
+        return _Dummy()

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/implementations/TensorFlow/common/modeling/performance.py

@@ -0,0 +1,56 @@
+# Lint as: python3
+# Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Functions and classes related to training performance."""
+
+import tensorflow as tf
+
+
+def configure_optimizer(optimizer,
+                        use_float16=False,
+                        use_graph_rewrite=False,
+                        loss_scale="dynamic"):
+  """Configures optimizer object with performance options."""
+  if use_float16:
+    # Wraps optimizer with a LossScaleOptimizer. This is done automatically
+    # in compile() with the "mixed_float16" policy, but since we do not call
+    # compile(), we must wrap the optimizer manually.
+    optimizer = (
+        tf.keras.mixed_precision.LossScaleOptimizer(
+            optimizer, loss_scale=loss_scale))
+  if use_graph_rewrite:
+    # Note: the model dtype must be 'float32', which will ensure
+    # tf.ckeras.mixed_precision and
+    # tf.compat.v1.mixed_precision.enable_mixed_precision_graph_rewrite do not double
+    # up.
+    optimizer = tf.compat.v1.mixed_precision.enable_mixed_precision_graph_rewrite(
+        optimizer)
+  return optimizer
+
+
+def set_mixed_precision_policy(dtype, loss_scale=None):
+  """Sets mix precision policy."""
+  if dtype == tf.float16:
+    policy = tf.keras.mixed_precision.Policy(
+        'mixed_float16', loss_scale=loss_scale)
+    tf.keras.mixed_precision.set_global_policy(policy)
+  elif dtype == tf.bfloat16:
+    policy = tf.keras.mixed_precision.Policy(
+        'mixed_bfloat16')
+    tf.keras.mixed_precision.set_global_policy(policy)
+  elif dtype == tf.float32:
+    tf.keras.mixed_precision.set_global_policy('float32')
+  else:
+    raise ValueError("Unexpected dtype: %s" % dtype)

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/implementations/TensorFlow/common/tb_utils.py

@@ -0,0 +1,357 @@
+import os
+import time
+import tensorflow as tf
+from copy import deepcopy
+from tensorboard.plugins.hparams import api as hp
+from tensorflow.python.eager import context
+from tensorflow.keras import backend as K
+from tensorflow.python.ops import summary_ops_v2
+from tensorflow.python.summary import summary as tf_summary
+from tensorflow.python.training.summary_io import SummaryWriterCache
+from tensorflow.compat.v1.keras.callbacks import TensorBoard, Callback
+
+
+def _remove_prefix(s, prefix):
+    if s.startswith(prefix):
+        s = s[len(prefix):]
+    return s
+
+
+def _parse_precision():
+    flag = os.environ.get('TF_BF16_CONVERSION', '0')
+    flag = flag.lower()
+    try:
+        value = int(flag)
+    except:
+        value = -1
+
+    if flag == 'false' or value == 0:
+        return 'fp32'
+    elif flag == 'true' or value == 1:
+        return 'bf16'
+    return flag
+
+
+def _set_precision_if_missing(hparams: dict):
+    if 'precision' not in hparams:
+        hparams['precision'] = _parse_precision()
+    return hparams
+
+
+def _copy_and_clean_hparams(hparams: dict):
+    hparams_ = dict()
+    for name, value in hparams.items():
+        if isinstance(value, (str, bool, int, float)):
+            hparams_[name] = value
+            continue
+
+        try:
+            hparams_[name] = str(value)
+            tf.compat.v1.logging.info(
+                f'Type of parameter "{name}" is not one of (bool, int, float, str). '
+                'It will be saved as a string.')
+        except:
+            tf.compat.v1.logging.info(
+                f'Conversion of parameter "{name}" to string failed. '
+                'Parameter will not be saved.')
+
+    return hparams_
+
+
+def write_hparams_v1(writer, hparams: dict):
+    hparams = _copy_and_clean_hparams(hparams)
+    hparams = _set_precision_if_missing(hparams)
+
+    with tf.compat.v1.Graph().as_default():
+        if isinstance(writer, str):
+            writer = SummaryWriterCache.get(writer)
+        summary = hp.hparams_pb(hparams).SerializeToString()
+        writer.add_summary(summary)
+
+
+def write_hparams_v2(writer, hparams: dict):
+    hparams = _copy_and_clean_hparams(hparams)
+    hparams = _set_precision_if_missing(hparams)
+
+    with writer.as_default():
+        hp.hparams(hparams)
+
+
+class ExamplesPerSecondEstimatorHook(tf.compat.v1.train.StepCounterHook):
+    """Calculate and report global_step/sec and examples/sec during runtime."""
+    # Copy-pasted from tensorflow_estimator/python/estimator/tpu/tpu_estimator.py
+
+    def __init__(self,
+                 batch_size=None,
+                 every_n_steps=1,
+                 every_n_secs=None,
+                 output_dir=None,
+                 summary_writer=None,
+                 extra_metrics=None,
+                 log_global_step=False,
+                 verbose=False):
+        super().__init__(
+            every_n_steps=every_n_steps,
+            every_n_secs=every_n_secs,
+            output_dir=output_dir,
+            summary_writer=summary_writer)
+        self._metrics = extra_metrics or {}
+        self._verbose = verbose
+        if log_global_step:
+            # Because estimator will log global_step/sec by default
+            # when log_step_count_steps is not None saving it here
+            # would duplicate events in TensorBoard.
+            # Use log_global_step=True when RunConfig.log_step_count_step=None
+            self._metrics['global_step/sec'] = 1
+        if batch_size is not None:
+            self._metrics['examples/sec'] = batch_size
+
+    def _add_summary(self, tag, value, step):
+        Summary = tf.compat.v1.Summary
+        global_step_summary = Summary(value=[
+            Summary.Value(tag=tag, simple_value=value)
+        ])
+        self._summary_writer.add_summary(global_step_summary, step)
+        if self._verbose:
+            tf.compat.v1.logging.info(f'{tag}: {value}')
+
+    def _log_and_record(self, elapsed_steps, elapsed_time, global_step):
+        global_step_per_sec = elapsed_steps / elapsed_time
+        if self._summary_writer is not None:
+            for name, factor in self._metrics.items():
+                value = factor * global_step_per_sec
+                self._add_summary(name, value, global_step)
+
+    def after_create_session(self, session, coord):
+        self._timer.reset()
+
+
+class ExamplesPerSecondKerasHookV1(Callback):
+    def __init__(self,
+                 every_n_steps=1,
+                 every_n_secs=None,
+                 output_dir=None,
+                 summary_writer=None,
+                 batch_size=None):
+        self.writer = summary_writer or SummaryWriterCache.get(output_dir)
+        self._timer = tf.compat.v1.train.SecondOrStepTimer(
+            every_n_secs, every_n_steps)
+        self._total_examples = 0
+        self._should_trigger = True
+        self._batch_size = batch_size
+
+    def on_train_begin(self, logs=None):
+        self._timer.reset()
+
+    def on_train_batch_begin(self, batch, logs=None):
+        self._should_trigger = self._timer.should_trigger_for_step(
+            logs.get('batch', batch))
+
+    def on_train_batch_end(self, batch, logs=None):
+        step = logs.get('batch', batch)
+        self._total_examples += logs.get('size', 0)
+        if self._should_trigger:
+            elapsed_time, elapsed_steps = self._timer.update_last_triggered_step(
+                step)
+            if elapsed_time is not None:
+                total_examples = self._total_examples
+                if self._batch_size is not None:
+                    total_examples = self._batch_size * elapsed_steps
+                self._log_and_record(
+                    elapsed_steps, elapsed_time, step, total_examples)
+                self._total_examples = 0
+
+    def _log_and_record(self, elapsed_steps, elapsed_time,
+                        global_step, total_examples=None):
+        Summary = tf.compat.v1.Summary
+        global_step_per_sec = elapsed_steps / elapsed_time
+        if self.writer is not None:
+            global_step_summary = Summary(value=[
+                Summary.Value(
+                    tag='global_step/sec', simple_value=global_step_per_sec)
+            ])
+            self.writer.add_summary(global_step_summary, global_step)
+            if total_examples is not None:
+                examples_per_sec = total_examples / elapsed_time
+                example_summary = Summary(value=[
+                    Summary.Value(tag='examples/sec',
+                                  simple_value=examples_per_sec)
+                ])
+                self.writer.add_summary(example_summary, global_step)
+
+
+class ExamplesPerSecondKerasHookV2(ExamplesPerSecondKerasHookV1):
+    def __init__(self,
+                 every_n_steps=1,
+                 every_n_secs=None,
+                 output_dir=None,
+                 summary_writer=None,
+                 batch_size=None):
+        writer = summary_writer or summary_ops_v2.create_file_writer_v2(output_dir)
+        super().__init__(every_n_steps, every_n_secs, output_dir, writer, batch_size)
+
+    def _log_and_record(self, elapsed_steps, elapsed_time,
+                        global_step, total_examples=None):
+        global_step_per_sec = elapsed_steps / elapsed_time
+        if self.writer is not None:
+            with self.writer.as_default(), summary_ops_v2.always_record_summaries():
+                summary_ops_v2.scalar('global_step/sec', global_step_per_sec,
+                                      step=global_step)
+                if total_examples is not None:
+                    examples_per_sec = total_examples / elapsed_time
+                    summary_ops_v2.scalar('examples/sec', examples_per_sec,
+                                          step=global_step)
+
+
+ExamplesPerSecondKerasHook = ExamplesPerSecondKerasHookV1
+
+
+class TBSummary(object):
+    """
+    Creates a proxy for FileWriter for TensorBoard.
+
+    :param log_dir: - path where experiment is running (usually the same as
+        model_dir in Estimator)
+    """
+
+    def __init__(self, log_dir: str):
+        super().__init__()
+        self._log_dir = log_dir
+        self._session = None
+
+    def __enter__(self):
+        self._session = tf.compat.v1.Session()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self._session:
+            self._session.close()
+            self._session = None
+
+    def add_scalar(self, tag, value, global_step=None):
+        with self._session:
+            writer = SummaryWriterCache.get(self._log_dir)
+            summary = tf.compat.v1.Summary(
+                value=[tf.compat.v1.Summary.Value(tag=tag, simple_value=value)])
+            event = tf.compat.v1.Event(summary=summary)
+            event.wall_time = time.time()
+            event.step = global_step
+            writer.add_event(event)
+
+
+class TensorBoardWithHParamsV1(TensorBoard):
+    """
+    Adds TensorBoard visualization to training process.
+
+    Writes training tfevent file into default log directory, but
+    stores evaluation in log_dir/eval subdirectory.
+    """
+
+    def __init__(self, hparams, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.hparams = hparams
+        self._train_summary = None
+        self._eval_summary = None
+
+    def _switch_writer(self, mode):
+        self.writer = self._train_summary if mode == 'train' else self._eval_summary
+
+    def _init_writer(self, model):
+        """Sets file writer."""
+        if context.executing_eagerly():
+            raise NotImplementedError('hook does not support eager execution')
+
+        self._train_summary = SummaryWriterCache.get(self.log_dir)
+        self._eval_summary = SummaryWriterCache.get(
+            os.path.join(self.log_dir, 'eval'))
+        self._switch_writer('train')
+
+        write_hparams_v1(self.writer, self.hparams)
+
+    def _write_custom_summaries(self, step, logs=None):
+        """
+        This methods works on the assumption that metrics containing `val`
+        in name are related to validation (that's the default in Keras).
+        """
+
+        logs = logs or {}
+        train_logs = {}
+        eval_logs = {}
+
+        for name, value in logs.items():
+            if 'val' in name:
+                if name.startswith('batch_val_'):
+                    name = 'batch_' + _remove_prefix(name, 'batch_val_')
+                elif name.startswith('epoch_val_'):
+                    name = _remove_prefix(name, 'epoch_val_')
+                eval_logs[name] = value
+            else:
+                if name.startswith('batch_'):
+                    name = _remove_prefix(name, 'batch_')
+                train_logs[name] = value
+
+        self._switch_writer('eval')
+        super()._write_custom_summaries(step, eval_logs)
+        self._switch_writer('train')
+        super()._write_custom_summaries(step, train_logs)
+
+
+class TensorBoardWithHParamsV2(TensorBoard):
+    """
+    Adds TensorBoard visualization to training process.
+
+    Writes training tfevent file into default log directory, but
+    stores evaluation in log_dir/eval subdirectory.
+    """
+
+    def __init__(self, hparams, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.hparams = hparams
+
+    def set_model(self, model):
+        """Sets Keras model and writes graph if specified."""
+        self.model = model
+        self._log_write_dir = self._get_log_write_dir()
+
+        self._train_dir = self._log_write_dir
+        self._train_step = self.model._train_counter  # pylint: disable=protected-access
+
+        self._val_dir = os.path.join(self._log_write_dir, 'eval')
+        self._val_step = self.model._test_counter  # pylint: disable=protected-access
+
+        self._writers = {}  # Resets writers.
+
+        self._should_write_train_graph = False
+        if self.write_graph:
+            self._write_keras_model_summary()
+            self._should_write_train_graph = True
+        if self.embeddings_freq:
+            self._configure_embeddings()
+
+        write_hparams_v2(self._train_writer, self.hparams)
+
+    def _log_epoch_metrics(self, epoch, logs):
+        """Writes epoch metrics out as scalar summaries.
+
+        Arguments:
+            epoch: Int. The global step to use for TensorBoard.
+            logs: Dict. Keys are scalar summary names, values are scalars.
+        """
+        if not logs:
+            return
+
+        train_logs = {k: v for k,
+                      v in logs.items() if not k.startswith('val_')}
+        val_logs = {k: v for k, v in logs.items() if k.startswith('val_')}
+        train_logs = self._collect_learning_rate(train_logs)
+
+        with summary_ops_v2.always_record_summaries():
+            if train_logs:
+                with self._train_writer.as_default():
+                    for name, value in train_logs.items():
+                        summary_ops_v2.scalar(name, value, step=epoch)
+            if val_logs:
+                with self._val_writer.as_default():
+                    for name, value in val_logs.items():
+                        name = name[4:]  # Remove 'val_' prefix.
+                        summary_ops_v2.scalar(name, value, step=epoch)

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/implementations/TensorFlow/common/training/__init__.py

@@ -0,0 +1,14 @@
+# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================