Add files using upload-large-folder tool

docker/bloom13b/Model-References/.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,31 @@
+# Description
+
+> :memo: Please include a summary of the changes. 
+>   
+> * List any dependencies that are required for the changes.  
+
+## Type of changes
+
+Please specify the type of changes, and delete the options that are not relevant.
+
+- [ ] Documentation update
+- [ ] Bug fix (changes which fix an issue)
+- [ ] Others (please specify)
+
+## Tests
+
+> :memo: Please describe the tests that you ran to verify your changes.
+>  
+> * Provide the instructions so that we can reproduce.  
+> * Please also list any relevant details for your test configuration.  
+
+## Checklist
+
+- [ ] I agree with the [Developer Certificate of Origin](https://developercertificate.org/).
+- [ ] My code conforms to the following coding guidelines:
+  - [ ] Use Python 3
+  - [ ] Python code follows [PEP 8 Coding Styles](https://www.python.org/dev/peps/pep-0008/)
+  - [ ] For TensorFlow models, use TensorFlow 2 high-level APIs
+- [ ] I have performed a self code review.
+- [ ] I have made corresponding changes to the documentation.
+- [ ] I have added tests that prove my fix is effective or that my feature works.

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

@@ -0,0 +1,725 @@
+# Running Habana MLPerf™ Benchmarks
+
+This directory provides instructions to reproduce Habana's results for [MLPerf Training v3.1](https://habana.ai/since-habanas-last-mlperf-submission/) **on 1 to 48 servers configurations with 8 Gaudi2 cards each.**
+
+For more information on training deep learning models using Gaudi, refer to [developer.habana.ai](https://developer.habana.ai/resources/)
+
+MLPerf™ is a trademark and service mark of MLCommons Association in the United States and other countries. All rights reserved. Unauthorized use is strictly prohibited.
+
+- [Running Habana MLPerf™ Benchmarks](#running-habana-mlperf-benchmarks)
+  - [Setup](#setup)
+    - [Prepare MLPerf Directory](#prepare-mlperf-directory)
+    - [Build and Deploy HabanaLabs MLPerf Training 3.1 Container](#build-and-deploy-habanalabs-mlperf-training-31-container)
+    - [Training Data for TensorFlow BERT](#training-data-for-tensorflow-bert)
+    - [Training Data for PyTorch BERT](#training-data-for-pytorch-bert)
+    - [Training Data for ResNet50](#training-data-for-resnet50)
+    - [Training Data for GPT3-175B](#training-data-for-gpt3-175b)
+    - [Dataset Preparation for PyTorch Stable Diffusion](#dataset-preparation-for-pytorch-stable-diffusion)
+  - [Training BERT](#training-bert)
+  - [Training ResNet50](#training-resnet50)
+  - [Training GPT3-175B](#training-gpt3-175b)
+  - [Training PyTorch Stable Diffusion](#training-pytorch-stable-diffusion)
+  - [Supported Configurations](#supported-configurations)
+  - [Changelog](#changelog)
+
+## Setup
+
+### Prepare MLPerf Directory
+
+On each compute node, perform the following:
+
+1. Follow the instructions provided in the [Gaudi Installation
+Guide](https://docs.habana.ai/en/latest/Installation_Guide/index.html) to set up the
+environment including the `$PYTHON` environment variable.
+The guide will walk you through the process of setting up your system to run the benchmarks on Gaudi.
+
+2. Create directories for scratch and dataset folders:
+    ```
+    export MLPERF_ROOT=/path/to/mlperf/root
+    export SCRATCH_DIR=$MLPERF_ROOT/scratch
+    export DATASETS_DIR=$MLPERF_ROOT/datasets
+    mkdir -p $SCRATCH_DIR
+    mkdir -p $DATASETS_DIR
+    ```
+
+    **Note:** If training is to be conducted on multiple nodes, it is essential to place the $DATASETS_DIR on a shared filesystem that is accessible by all the nodes. This allows for dataset preparation to be performed only once in the `Training Data for <configuration>` sections, enabling all nodes to access the prepared dataset during training.
+
+3. Clone Model-References repository and switch to the branch that matches your SynapseAI version. You can run the
+[`hl-smi`](https://docs.habana.ai/en/latest/Management_and_Monitoring/System_Management_Tools_Guide/System_Management_Tools.html#hl-smi-utility-options)
+utility to determine the SynapseAI version.
+
+    ```bash
+    cd $MLPERF_ROOT
+    git clone -b [SynapseAI version] https://github.com/HabanaAI/Model-References
+    export MLPERF_DIR=$MLPERF_ROOT/Model-References/MLPERF3.1/Training
+    ```
+
+### Build and Deploy HabanaLabs MLPerf Training 3.1 Container
+
+To build MLPerf training 3.1 container, perform the following:
+
+1. Copy ssh keys to enable passwordless ssh to /root/.ssh/
+2. Set the environment variables for the docker command.
+   * To find a docker image, go to [gaudi-docker](https://vault.habana.ai/ui/repos/tree/General/gaudi-docker).
+   * Open gaudi-docker directory, and select the folder that matches the SynapseAI version (determined by running [`hl-smi`](https://docs.habana.ai/en/latest/System_Management_Tools_Guide/System_Management_Tools.html#hl-smi-utility-options)).
+   * Navigate to subdirectories, choose system and framework version.
+   * Choose the docker build version. Most often 'latest' will be used.
+   * Navigate to "Docker Info" tab and note "Title" string.
+   * Set `DOCKER_IMAGE` to "Title" string with `vault.habana.ai/gaudi-docker/` prefix. See the examples below.
+     * Example on TensorFlow Container:
+          ```bash
+          # NOTE: The below is only an example value. Replace [SynapseAI version] and [TF version] to match your setup and Supported Configuration.
+          export DOCKER_IMAGE=vault.habana.ai/gaudi-docker/[SynapseAI version]/ubuntu20.04/habanalabs/tensorflow-installer-tf-cpu-[TF version]:latest
+          export CONTAINER_NAME=mlperf3_1
+          ```
+      * Example on PyTorch Container:
+          ```bash
+          # NOTE: The below is only an example value. Replace [SynapseAI version] and [PT version] to match your setup and Supported Configuration.
+          export DOCKER_IMAGE=vault.habana.ai/gaudi-docker/[SynapseAI version]/ubuntu20.04/habanalabs/pytorch-installer-[PT Version]:latest
+          export CONTAINER_NAME=mlperf3_1
+          ```
+
+3. Create `mlperf3.1` container by running the following command.
+
+    ```bash
+    docker run --privileged --security-opt seccomp=unconfined \
+      --name $CONTAINER_NAME -td                              \
+      -v /dev:/dev                                            \
+      --device=/dev:/dev                                      \
+      -e LOG_LEVEL_ALL=6                                      \
+      -v /sys/kernel/debug:/sys/kernel/debug                  \
+      -v /tmp:/tmp                                            \
+      -v $MLPERF_DIR:/root/MLPERF                             \
+      -v $DATASETS_DIR:/root/datasets                         \
+      -v $SCRATCH_DIR:/root/scratch                           \
+      --cap-add=sys_nice --cap-add=SYS_PTRACE                 \
+      --user root --workdir=/root --net=host                  \
+      --ulimit memlock=-1:-1 ${DOCKER_IMAGE}
+    ```
+
+4. Start the docker.
+
+    ```bash
+    docker exec $CONTAINER_NAME bash -c "service ssh start"
+    docker exec -it $CONTAINER_NAME bash
+    ```
+
+    **Note:** The following two steps are only necessary for training on multiple nodes.
+
+5. In the docker, create `/root/shared/hosts` file that contains a list of all host IPs in the cluster. Add one IP per line. Below is an example for 4 nodes (32 devices).
+    ```
+    mkdir /root/shared
+    echo '10.10.100.101' > /root/shared/hosts
+    echo '10.10.100.102' >> /root/shared/hosts
+    echo '10.10.100.103' >> /root/shared/hosts
+    echo '10.10.100.104' >> /root/shared/hosts
+    ```
+
+6. SSH is used to spawn local and remote processes. In order to allow communication between machines it is required to provide a passwordless _ssh_ communication and set default port for connection. It has to be done on all of the machines:
+    ```
+    mkdir .ssh
+    printf 'Host *\n    StrictHostKeyChecking no\nPort 3022' >> .ssh/config
+    ```
+    It also may be necessary to setup SSH keys and add them to `~/.ssh/authorized_keys`.
+
+### Training Data for TensorFlow BERT
+
+1. Log into mlperf3.1 TensorFlow container and install the requirements:
+    <!-- DATASET download_mlperf_bert_tensorflow -->
+    <!-- DATASET process_mlperf_bert_tensorflow -->
+    ```bash
+    export BERT_PATH=/root/MLPERF/benchmarks/bert/implementations/TensorFlow/nlp/bert
+    cd $BERT_PATH
+    pip install -r requirements.txt
+    ```
+    <!-- /DATASET process_mlperf_bert_tensorflow -->
+    <!-- /DATASET download_mlperf_bert_tensorflow -->
+
+2. Download the required files from Google drives.
+    <!-- DATASET download_mlperf_bert_tensorflow -->
+    ```bash
+    export TENSORFLOW_BERT_DATA=/root/datasets/tensorflow_bert
+    bash pretraining/prepare_dataset.sh \
+      --data-path $TENSORFLOW_BERT_DATA \
+      --only-download
+    ```
+    <!-- /DATASET download_mlperf_bert_tensorflow -->
+
+    After completing this step, there should be a `$TENSORFLOW_BERT_DATA/input` folder containing the following files:
+    ```
+    bert_config.json
+    model.ckpt-28252.data-00000-of-00001
+    model.ckpt-28252.index
+    model.ckpt-28252.meta
+    results_text.tar.gz
+    vocab.txt
+    ```
+
+3. Prepare the packed dataset by running the command below:
+    <!-- DATASET process_mlperf_bert_tensorflow -->
+    ```bash
+    bash pretraining/prepare_dataset.sh \
+      --scripts-path $BERT_PATH \
+      --data-path $TENSORFLOW_BERT_DATA \
+      --only-preprocessing \
+      --jobs-limit 25
+    ```
+    <!-- /DATASET process_mlperf_bert_tensorflow -->
+
+    This step will take multiple hours to complete.
+    The exact time depends on the machine setup and the speed of storage that contains the dataset.
+    The `--jobs-limit` option limits the number of pararell processes for converting and packing tfrecords.
+    This step is resource consuming,
+    and the machine running it must have a minimum of 32 CPUs and 755GB of RAM to ensure proper functioning.
+
+4. `$TENSORFLOW_BERT_DATA` should now contain following folders:
+    ```
+    checkpoint
+    eval_dataset
+    input
+    packed_data_500
+    unpacked_data
+    ```
+
+    `input` folder can be removed if the preprocessing has been successfully completed.
+    By default, TensorFlow BERT uses only packed data for training,
+    as described in the scenario mentioned described [here](#training-for-tensorflow-bert).
+    In such cases, the `unpacked_data` is unnecessary and can be deleted.
+
+### Training Data for PyTorch BERT
+
+#### Dataset Preparation
+
+Log into mlperf3.1 PyTorch container and run:
+<!-- DATASET download_mlperf_bert_pytorch -->
+<!-- DATASET process_mlperf_bert_pytorch -->
+```bash
+cd /root/MLPERF/benchmarks/bert/implementations/PyTorch
+pip install -r requirements.txt
+export PYTORCH_BERT_DATA=/root/datasets/pytorch_bert
+```
+<!-- /DATASET process_mlperf_bert_pytorch -->
+```bash
+bash input_preprocessing/prepare_data.sh -o $PYTORCH_BERT_DATA
+```
+<!-- /DATASET download_mlperf_bert_pytorch -->
+
+At this stage, ```$PYTORCH_BERT_DATA/phase1``` checkpoint and  ```$PYTORCH_BERT_DATA/hdf5/eval_varlength``` evaluation data are ready, while ```$PYTORCH_BERT_DATA/hdf5/training_4320/hdf5_4320_shards_uncompressed``` training data requires packing as described in the following section.
+
+#### Training Data Packing
+
+Once the training data is ready, pack it using a similar code as described in [GraphCore for v1.0 Submission](https://github.com/mlcommons/training_results_v1.0/tree/master/Graphcore/benchmarks/bert/implementations/popart/bert_data).
+
+<!-- DATASET process_mlperf_bert_pytorch -->
+```bash
+mkdir $PYTORCH_BERT_DATA/packed
+python3 pack_pretraining_data_pytorch.py \
+    --input_dir=$PYTORCH_BERT_DATA/hdf5/training-4320/hdf5_4320_shards_uncompressed \
+    --output_dir=$PYTORCH_BERT_DATA/packed \
+    --max_predictions_per_seq=76
+```
+<!-- /DATASET process_mlperf_bert_pytorch -->
+
+For further details, refer to [Packing: Towards 2x NLP BERT Acceleration](https://arxiv.org/abs/2107.02027).
+
+### Training Data for ResNet50
+
+The instructions for the ImageNet dataset is applicable for both PyTorch and TensorFlow ResNet50.
+
+ 1. Sign up with [image-net.org](http://image-net.org/download-images) and acquire the rights to download original images.
+ 2. Follow the link to the 2012 ILSVRC and download ILSVRC2012_img_val.tar and ILSVRC2012_img_train.tar.
+ Place the files in the folder that will be mapped in mlperf3.1 container (for example, `$DATASETS_DIR`).
+ 3. Run the script below in mlperf3.1 container (PyTorch or TensorFlow) to unpack the dataset:
+
+    ```
+    bash /root/MLPERF/benchmarks/resnet/scripts/unpack_imagenet.sh \
+        --train-archive /path/to/ILSVRC2012_img_train.tar \
+        --validation-archive /path/to/ILSVRC2012_img_val.tar \
+        --output-path /root/datasets/imagenet \
+        --jobs-number 16
+    ```
+
+    The script unpacks training and validation packages in parallel.
+    In addition, when upacking subarchives from ILSVRC2012_img_train.tar,
+    `--jobs-number` defines number of pararell processes allocated for the task.
+    Scripts runtime is dependent in large part on the data access speed of the storage where $DATASETS_DIR is located.
+
+### Training Data for GPT3-175B
+
+#### Dataset Preparation for GPT3-175B
+
+Dataset preparation should be done in the following docker:
+
+```
+docker run --ipc=host -it -v $DATASETS_DIR:/root/datasets -v $MLPERF_DIR:/root/MLPERF nvcr.io/nvidia/pytorch:22.11-py3 bash
+```
+
+MLPerf GPT3 is trained using C4/en/3.0.1 dataset. It can be downloaded from https://huggingface.co/datasets/allenai/c4. Instruction is clear on how to select precisely the files for downloading.
+
+```
+apt-get update
+apt-get install git-lfs
+mkdir -p /root/datasets/gpt3
+cd /root/datasets/gpt3
+GIT_LFS_SKIP_SMUDGE=1 git clone https://huggingface.co/datasets/allenai/c4
+cd c4
+git lfs pull --include "en/*"
+```
+
+Out of all the files, only 256 will be required for training, and 8 for validation.
+You can merge them into three .json.gz files using the following commands, which are taken from https://github.com/mlcommons/training/blob/master/large_language_model/megatron-lm/README.md.
+
+```
+# create softlinks to store each shard before merging
+mkdir -p softlinks
+for shard in {6..7}; do
+  start=$((shard * 128))
+  end=$((shard * 128 + 127))
+  mkdir -p softlinks/en_$shard
+  for ind in $(seq -f "%05g" $start $end); do
+    ln -s ../../en/c4-train.${ind}-of-01024.json.gz softlinks/en_${shard}/c4-train.${ind}-of-01024.json.gz
+  done
+done
+
+# merge
+mkdir -p en_merge
+for shard in {6..7}; do
+  cat softlinks/en_${shard}/*gz > en_merge/c4-train.en_${shard}.json.gz
+done
+cat en/c4-validation.0000* > en_merge/c4-validation.json.gz
+```
+
+To tokenize the prepared files, you need to download the tokenizer model, vocab_c4_en_301_5Mexp2_spm.model, and the vocabulary file, vocab_c4_en_301_5Mexp2_spm.vocab, from the following location:
+https://console.cloud.google.com/storage/browser/mlperf-llm-public2;tab=objects?prefix=&forceOnObjectsSortingFiltering=false.
+Please note that registration is required to access these files. Tokenization can be performed using the following commands.
+Please be aware that this conversion process may take several hours.
+
+```
+git clone https://github.com/NVIDIA/NeMo.git
+cd NeMo && git checkout f3ad584b94170bc3ea197df29eb9ef9c96061730 && bash ./reinstall.sh && cd ..
+
+mkdir -p preprocessed_c4_spm
+for shard in {6..7}; do
+python3 NeMo/scripts/nlp_language_modeling/preprocess_data_for_megatron.py \
+    --input en_merge/c4-train.en_${shard}.json.gz \
+    --tokenizer-library sentencepiece \
+    --tokenizer-model vocab_c4_en_301_5Mexp2_spm.model \
+    --output-prefix preprocessed_c4_spm/c4_en_${shard}_c4_spm \
+    --dataset-impl mmap \
+    --workers 128
+done
+
+python3 NeMo/scripts/nlp_language_modeling/preprocess_data_for_megatron.py \
+    --input en_merge/c4-validation.json.gz \
+    --tokenizer-library sentencepiece \
+    --tokenizer-model vocab_c4_en_301_5Mexp2_spm.model \
+    --output-prefix preprocessed_c4_spm/c4_en_validation_c4_spm \
+    --dataset-impl mmap \
+    --workers 128
+```
+
+The resulting files to be used during training are as follows:
+* ```preprocessed_c4_spm/c4_en_6_c4_spm_text_document.bin```
+* ```preprocessed_c4_spm/c4_en_6_c4_spm_text_document.idx```
+* ```preprocessed_c4_spm/c4_en_7_c4_spm_text_document.bin```
+* ```preprocessed_c4_spm/c4_en_7_c4_spm_text_document.idx```
+* ```preprocessed_c4_spm/c4_en_validation_c4_spm_text_document.bin```
+* ```preprocessed_c4_spm/c4_en_validation_c4_spm_text_document.idx```
+
+In addition to the dataset, GPT3 implementation requires https://huggingface.co/gpt2/resolve/main/vocab.json and https://huggingface.co/gpt2/resolve/main/merges.txt files:
+
+```
+wget "https://huggingface.co/gpt2/resolve/main/vocab.json" -P preprocessed_c4_spm
+wget "https://huggingface.co/gpt2/resolve/main/merges.txt" -P preprocessed_c4_spm
+```
+
+In order to exclude graph compilation time from Time To Train, you need to prepare a synthetic dataset for device warmup:
+```
+python3 /root/MLPERF/benchmarks/gpt3/tools/create_synthetic_dataset.py \
+    --valid_files_path preprocessed_c4_spm/c4_en_validation_c4_spm_text_document \
+    --output_path preprocessed_c4_spm/
+```
+
+The commandline above will create synthetic files:
+* ```preprocessed_c4_spm/synthetic_text_document.bin```
+* ```preprocessed_c4_spm/synthetic_text_document.idx```
+
+#### Checkpoint Preparation for GPT3-175B
+
+Log into mlperf3.1 PyTorch container. Install DeepSpeed and other requirements:
+```
+pip install git+https://github.com/HabanaAI/DeepSpeed.git
+pip install -r /root/MLPERF/benchmarks/gpt3/requirements.txt
+```
+
+The checkpoint for MLPerf GPT3 in the paxml format can be downloaded from
+[gs://mlperf-llm-public2/gpt3_spmd1x64x24_tpuv4-3072_v84_20221101/checkpoints/checkpoint_00004000](gs://mlperf-llm-public2/gpt3_spmd1x64x24_tpuv4-3072_v84_20221101/checkpoints/checkpoint_00004000).
+The common_bf16.json can be downloaded from: https://github.com/ShriyaPalsamudram/training/tree/LLM-NVIDIA-reference-draft/large_language_model/megatron-lm/scripts.
+At one stage, there will be a merged directory and a universal directory, each requiring 2 TB of disk space for 96L. Therefore, to complete all the steps, it is necessary to have over 4TB of free disk space.
+Additionally, the machine must have a minimum of 32 CPUs and 755GB of RAM to ensure proper functioning.
+Before the checkpoint can be used, it must be converted by following the steps below:
+
+1. Convert the paxml checkpoint to Megatron distributed using /root/MLPERF/benchmarks/gpt3/tools/convert_checkpoint/convert_paxml_optimizer.py
+
+    ```
+    python3 /root/MLPERF/benchmarks/gpt3/tools/convert_checkpoint/convert_paxml_optimizer.py \
+            --google_ckpts checkpoint_00004000/ \
+            --output_dir megatron_merged_ckpt \
+            --num_layers 96 \
+            --params_file common_bf16.json \
+            --pool 1
+    ```
+
+2. Convert Megatron merged checkpoint to DeepSpeed universal.
+
+    To generate the mp-rank-files required in megatron_optim_merged_to_ds_universal_convert.py, the user needs to run GPT-3, which will generate these files based on the configuration used in the run.
+    This can be obtained by running a single step of GPT-3 and saving the checkpoint.
+    Please note that only this particular step of checkpoint peparation must be done using 8 HLS2 machines. The remaining steps can be performed on a CPU-only machine.
+    Please make sure /root/shared/hosts file contains a list of 8 IPs for HLS2 machines and SSH communication is properly configured.
+    For further details, refer to points 5 and 6 [here](#build-and-deploy-habanalabs-mlperf-training-31-container).
+    Once the setup is ready, proceed to run the single step for GPT3 as follows:
+    ```
+    mkdir checkpoint_with_mp_rank_files
+    bash /root/MLPERF/benchmarks/gpt3/run_gpt.sh --hosts /root/shared/hosts --data-dir /root/datasets/ --output-dir /root/scratch --num-nodes 8 --data-parallel-size 1 --start-from-ckpt false --save-checkpoints-dir checkpoint_with_mp_rank_files --exit-interval 1 --global-batch-size 2048
+    ```
+
+    Run megatron_optim_merged_to_ds_universal_convert.py to create the universal checkpoint:
+
+    ```
+    mkdir -p /root/datasets/gpt3/universal-checkpoint
+    python3 /root/MLPERF/benchmarks/gpt3/tools/convert_checkpoint/megatron_optim_merged_to_ds_universal_convert.py \
+        --o /root/datasets/gpt3/universal-checkpoint/ --ds-mp-rank-files-dir checkpoint_with_mp_rank_files --megatron-lm-merged-input-dir megatron_merged_ckpt \
+        --tp 8 --pp 8 --nl 96 --iteration 3000 --global-batch-size 2048 --seq_length 2048 --lr-decay-samples 166809600 --lr-warmup-samples 407040 \
+        --pool 64 --model-parallel-same-config False --update-only-mp-rank-files False
+    ```
+
+### Dataset Preparation for PyTorch Stable Diffusion
+
+The instruction for preparing the dataset is based on original MLCommons instruction.
+Please follow instructions under the following link for more details:
+https://github.com/mlcommons/training/tree/master/stable_diffusion
+
+#### Generate training dataset (Preprocessed moments dataset):
+
+Log into mlperf3.1 PyTorch container
+```
+export DATASET_PATH=/root/datasets/stable_diffusion/datasets/laion-400m/webdataset-moments-filtered
+
+bash /root/MLPERF/benchmarks/stable_diffusion/scripts/datasets/laion400m-filtered-download-moments.sh --output-dir $DATASET_PATH
+```
+
+#### Generate validation dataset
+
+Log into mlperf3.1 PyTorch container
+```
+export DATASET_DIR=/root/datasets/stable_diffusion/datasets/coco2014
+
+bash /root/MLPERF/benchmarks/stable_diffusion/scripts/datasets/coco2014-validation-download-prompts.sh --output-dir $DATASET_DIR
+```
+##### Set ANNOTATION_FILE to the downloaded annotation file
+
+```
+export ANNOTATION_FILE=$DATASET_DIR/val2014_30k.tsv
+```
+
+```
+bash /root/MLPERF/benchmarks/stable_diffusion/scripts/datasets/coco2014-validation-download-stats.sh --output-dir $DATASET_DIR
+```
+
+##### Set FID_GT_PATH to the downloaded npz file used for inception
+```
+export FID_GT_PATH=$DATASET_DIR/val2014_30k_stats.npz
+```
+
+#### Download the base checkpoint for Stable Diffusion: UNet, VAE, and OpenCLIP text embedder:
+Reference: https://github.com/mlcommons/training/tree/master/stable_diffusion#downloading-the-checkpoints
+
+Log into mlperf3.1 PyTorch container
+```
+export DATASET_DIR=/root/datasets/stable_diffusion/datasets/checkpoints/sd
+
+bash /root/MLPERF/benchmarks/stable_diffusion/scripts/checkpoints/download_sd.sh --output-dir $DATASET_DIR
+
+export BASE_CKPT=$DATASET_DIR/512-base-ema.ckpt
+```
+
+
+#### Generate the synthetic dataset for Stable Diffusion (warmup)
+
+Uncompress any one data tar file from training data "example: $DATASET_PATH/00001.tar" and keep it in the input directory path. Set environment variables for input and output path and run the below script to generate the synthetic data at the output directory
+
+Log into mlperf3.1 PyTorch container
+```
+cp /root/datasets/stable_diffusion/datasets/laion-400m/webdataset-moments-filtered/00001.tar /root/datasets/stable_diffusion/datasets/input_uncompressed_file/
+
+cd /root/datasets/stable_diffusion/datasets/input_uncompressed_file/
+
+tar -xvf 00001.tar; cd -;
+
+export DATASET_PATH_UNCOMPRESSED=/root/datasets/stable_diffusion/datasets/input_uncompressed_file
+export DATASET_PATH_OUTPUT=/root/datasets/stable_diffusion/datasets/
+
+cd /root/MLPERF/benchmarks/stable_diffusion/scripts;
+bash prepare_synthetic_data.sh; cd -;
+```
+
+After synthetic data preparation, copy generated SD_synthetic_data_10001.tar file to the path used via WARMUP_FILE in training
+
+```
+export WARMUP_FILE=$DATASET_PATH_OUTPUT//SD_synthetic_data_10001.tar
+```
+
+## Training BERT
+
+### Training TensorFlow BERT
+
+1. Inside the mlperf3.1 TensorFlow container, install BERT requirements.
+    ```bash
+    export BERT_IMPLEMENTATIONS=/root/MLPERF/benchmarks/bert/implementations
+    pip install -r $BERT_IMPLEMENTATIONS/TensorFlow/nlp/bert/requirements.txt
+    ```
+
+2. Run the training.
+    ```bash
+    cd $BERT_IMPLEMENTATIONS/HLS-Gaudi2-TF
+    ./launch_bert_hvd.sh --config defaults.cfg
+    ```
+
+### Training PyTorch BERT
+
+1. Inside the mlperf3.1 PyTorch container, install BERT requirements.
+    ```bash
+    export BERT_IMPLEMENTATIONS=/root/MLPERF/benchmarks/bert/implementations
+    pip install -r $BERT_IMPLEMENTATIONS/PyTorch/requirements.txt
+    ```
+
+2. Run the training.
+    ```bash
+    export PYTORCH_BERT_DATA=/root/datasets/pytorch_bert
+    cd $BERT_IMPLEMENTATIONS/HLS-Gaudi2-PT
+    ./launch_bert_pytorch.sh --data-dir $PYTORCH_BERT_DATA
+    ```
+### TTT (Time to Train) Calculation for BERT
+
+Results can be found in following output files:
+* /tmp/bert_pretrain/phase_2/result_rank_0.txt for TensorFlow BERT
+* /tmp/BERT_PRETRAINING/results/checkpoints/result_rank_0.txt for PyTorch BERT
+
+To get the TTT from the training script output, run following command:
+
+```bash
+grep 'run_start\|run_stop' /path/to/output/file | grep worker0 | awk '{print $5}' | tr -d ',' | paste -sd " " - | awk '{print ($2 - $1) / 1000 / 60}'
+```
+
+
+## Training ResNet50
+
+### Training TensorFlow ResNet50
+
+1. Inside the mlperf3.1 TensorFlow container, install Resnet50 requirements.
+    ```bash
+    export RESNET_IMPLEMENTATIONS=/root/MLPERF/benchmarks/resnet/implementations
+    pip install -r $RESNET_IMPLEMENTATIONS/TensorFlow/computer_vision/Resnets/resnet_keras/requirements.txt
+    ```
+
+2. Run the training.
+    ```bash
+    cd $RESNET_IMPLEMENTATIONS/HLS-Gaudi2-TF
+    ./launch_keras_resnet_hvd.sh --config $(pwd)/batch_256.cfg --jpeg-data-dir /root/datasets/imagenet --log_dir /tmp/resnet_log
+    ```
+
+### Training PyTorch ResNet50
+
+1. Inside the mlperf3.1 PyTorch container, install Resnet50 requirements.
+    ```bash
+    export RESNET_IMPLEMENTATIONS=/root/MLPERF/benchmarks/resnet/implementations
+    pip install -r $RESNET_IMPLEMENTATIONS/HLS-Gaudi2-PT/PyTorch/requirements.txt
+    ```
+
+2. Run the training.
+    ```bash
+    cd $RESNET_IMPLEMENTATIONS/HLS-Gaudi2-PT
+    ./launch_resnet.sh --config batch_256.cfg --data-dir /root/datasets/imagenet
+    ```
+
+### TTT (Time to Train) Calculation for ResNet50
+
+To get the TTT from the training script output, run following command:
+
+```bash
+grep 'run_start\|run_stop' /tmp/resnet_log/result_rank_0.txt | grep worker0 | awk '{print $5}' | tr -d ',' | paste -sd " " - | awk '{print ($2 - $1) / 1000 / 60}'
+```
+
+## Training GPT3-175B
+
+All the training steps for GPT3-175B should be performed in mlperf3.1 PyTorch container.
+
+### Installing Requirements
+
+The following requirements need to be installed on all machines participating in the training:
+```
+pip install git+https://github.com/HabanaAI/DeepSpeed.git
+pip install -r /root/MLPERF/benchmarks/gpt3/requirements.txt
+```
+
+### Run and time
+
+The latest Intel-HabanaLabs's software supports 8-bit floating-point precision (FP8) training for GPT3 model and MLPerf3.1 submissions for GPT3 have been conducted using FP8 precision.
+Running the GPT3 model requires multiple machines. For example, 32 HLS2 machines: `HLS-Gaudi2-N32-PT system` or 48 HLS2 machines `HLS-Gaudi2-N48-PT system`.
+
+Please set the paths for the dataset and the universal checkpoint, which should be created during [setup phase](#training-data-for-gpt3-175b).
+```
+export DATASET_DIR=/root/datasets/gpt3/c4/preprocessed_c4_spm
+export CHECKPOINT_DIR=/root/datasets/gpt3/universal-checkpoint
+```
+
+Please make sure /root/shared/hosts file contains a list of IPs for HLS2 machines, and that SSH communication is properly configured.
+For further details, refer to points 5 and 6 [here](#build-and-deploy-habanalabs-mlperf-training-31-container).
+
+#### Running GPT3 on HLS-Gaudi2-N32-PT System
+```
+bash /root/MLPERF/benchmarks/gpt3/run_gpt.sh --data-dir $DATASET_DIR/ --universal-ckpt-path $CHECKPOINT_DIR/ \
+--hosts /root/shared/hosts --output-dir /root/scratch --num-nodes 32 --data-parallel-size 4 --save-checkpoints false --mllog-output-path /root/scratch/result.txt --train-samples 6782976 --use-fp8-transformer-engine --global-batch-size 2048 --micro-batch-size 2 --eval-interval 12 --device-warmup true --device-warmup-dataset-path $DATASET_DIR/synthetic_text_document
+```
+
+#### Running GPT3 on HLS-Gaudi2-N48-PT System
+```
+bash /root/MLPERF/benchmarks/gpt3/run_gpt.sh --data-dir $DATASET_DIR/ --universal-ckpt-path $CHECKPOINT_DIR/ \
+--hosts /root/shared/hosts --output-dir /root/scratch --num-nodes 48 --data-parallel-size 8 --pipeline-model-parallel-size 6 --save-checkpoints false --mllog-output-path /root/scratch/result.txt --train-samples 6782976 --global-batch-size 2048 --micro-batch-size 2 --eval-interval 12 --device-warmup true --device-warmup-dataset-path $DATASET_DIR/synthetic_text_document --use-fp8-transformer-engine
+```
+
+Training results will be stored in `/root/scratch` folder.
+
+The `--save-checkpoints` is set to `false` as 96l checkpoints take a lot of disc space. In order to save the checkpoint after the run or save it with some frequency, please use `--save-checkpoints true` and manipulate `--save-interval` parameter.
+The script will start from universal checkpoint and train up to 312 steps or the time, when validation log perplexity is below 2.69. According to the convergence point of GPT3 on HLS system, it should approximately run for 288 steps in order to reach 2.69 validation log perplexity. To reduce number of steps, you can use `--exit-interval` parameter or reduce train samples by `--train-samples` parameter.
+
+### TTT (Time to Train) Calculation for GPT3-175B
+
+To get the TTT from the training script output, run the following command:
+
+```bash
+grep 'run_start\|run_stop' /root/scratch/result.txt | awk '{print $5}' | tr -d ',' | paste -sd " " - | awk '{print ($2 - $1) / 1000 / 60}'
+```
+
+## Training PyTorch Stable Diffusion
+
+#### Run the traning and validation steps
+Following environment variables will be used to specify before training:
+
+```
+DATASET_PATH:= to the path where preprocessed data is located
+ANNOTATION_FILE:= is the annotation file used for validation
+FID_GT_PATH:= is the path for npz file used for inception
+RESULTS_DIR:= to the path you want to save the results and checkpoint
+POSTFIX_LOG_DIR:= postfix for logdir
+WARMUP_FILE:= is the file used only in the warmup of the training
+BASE_CKPT:= is the base checkpoint
+```
+
+```
+For example:
+export DATASET_PATH="/root/datasets/stable_diffusion/datasets/laion-400m/webdataset-moments-filtered/{00000..00831}.tar"
+export ANNOTATION_FILE="/root/datasets/stable_diffusion/datasets/coco2014/val2014_30k.tsv"
+export FID_GT_PATH="/root/datasets/stable_diffusion/datasets/coco2014/val2014_30k_stats.npz"
+export RESULTS_DIR="/tmp/"
+export POSTFIX_LOG_DIR="64x_run"
+export WARMUP_FILE="/root/datasets/stable_diffusion/datasets/SD_synthetic_data_10001.tar"
+export BASE_CKPT="/root/datasets/stable_diffusion/datasets/checkpoints/sd/512-base-ema.ckpt"
+```
+
+### Running Stable Difussion training on HLS-Gaudi2-N8-PT System
+
+#### Follow below steps in sequence on each worker:
+
+#### Step1: Installing Requirements
+Log into mlperf3.1 PyTorch container and install the requirements
+```
+pip install -r /root/MLPERF/benchmarks/stable_diffusion/scripts/requirements.txt
+```
+
+#### Step2: Initialization to Clear Cache and Initialize MLLogging
+```
+bash /root/MLPERF/benchmarks/stable_diffusion/scripts/run_init.sh
+```
+
+#### Step3: Training
+Each worker will have training command:
+
+```
+For example:
+MASTER_PORT=${MASTER_PORT} MASTER_ADDR=${MASTER_ADDR} NODE_RANK={NODE_RANK} python3 -u root/MLPERF/benchmarks/stable_diffusion/main.py  \
+   lightning.trainer.num_nodes=8 data.params.train.params.urls=${DATASET_PATH} lightning.modelcheckpoint.params.every_n_train_steps=1000 \
+   data.params.validation.params.annotations_file=${ANNOTATION_FILE}                                                                     \
+   lightning.trainer.max_steps=5000 lightning.trainer.val_check_interval=<Greater_than_max_steps_to_avoid_online_val>                    \
+   lightning.modelcheckpoint.params.save_last=False model.params.hpu_graph=True -m train --ckpt {BASE_CKPT}                              \
+   -b configs/train_08x08x08.yaml -l {RESULTS_DIR} --autocast --warmup {WARMUP_FILE} --async_checkpoint -n {POSTFIX_LOG_DIR}
+```
+
+#### Step4: Offline validation for the checkpoints generated
+```
+For example:
+MASTER_PORT=${MASTER_PORT} MASTER_ADDR=${MASTER_ADDR} NODE_RANK={NODE_RANK} python3 -u root/MLPERF/benchmarks/stable_diffusion/main.py  \
+   lightning.trainer.num_nodes=8 data.params.validation.params.annotations_file=${ANNOTATION_FILE}                                       \
+   model.params.validation_config.fid.gt_path=${FID_GT_PATH} model.params.load_unet=True -m validate                                     \
+   --ckpt {RESULTS_DIR}/checkpoints/'epoch=000000-step=00000x000.ckpt' -b {BASE_CKPT} -b configs/train_08x08x08.yaml          \
+   --current_validation_iter {Current_validation_iteration_number} --validation_iters {Total_validation_iteration_numbers}
+```
+
+## Supported Configurations
+### TensorFlow ResNet-50, PyTorch BERT, PyTorch ResNet-50, PyTorch GPT3-175B
+
+| Validated on | SynapseAI Version | Framework Version(s) |   Mode   |
+| :----------: | :---------------: | :------------------: | :------: |
+|    Gaudi2    |      1.14.0       |  TensorFlow 2.15.0   | Training |
+|    Gaudi2    |      1.14.0       |    PyTorch 2.1.1     | Training |
+
+### TensorFlow BERT,  PyTorch Stable Diffusion
+
+| Validated on | SynapseAI Version | Framework Version(s) |   Mode   |
+| :----------: | :---------------: | :------------------: | :------: |
+|    Gaudi2    |      1.13.0       |  TensorFlow 2.13.1   | Training |
+|    Gaudi2    |      1.13.0       |    PyTorch 2.1.0     | Training |
+
+## Changelog
+### 1.14.0
+- Updated scripts to enable dynamic shapes support for topologies:
+    - PyTorch Bert
+### 1.13.0
+- Updated scripts to cover MLPerf 3.1 submission, including but not limited to:
+  - Optimized GPT3 code by:
+    - FP8 support;
+    - Sequence Parallelism support;
+    - Fused Scaled Dot Product Attention;
+    - Device warmup.
+  - Added new benchmark: Stable Diffusion;
+  - Enabled using HPU Graphs by default for PyTorch ResNet50;
+  - Removed UNet3D and Bert 64xcards from submission.
+### 1.12.0
+- Removed the setting of the PT_HPU_LAZY_MODE environment variable in the script for Bert and ResNet50.
+- Removed unused PT_HPU_ENABLE_SYNC_OUTPUT_HOST environment variable.
+### 1.11.0
+ - Updated scripts to cover MLPerf 3.0 submission.
+ - Switched UNet3D, Bert, ResNet50 from HMP to Autocast.
+ - Added script for ImageNet unpacking.
+ - Reworked scripts and instruction for TensorFlow BERT data preprocessing.
+ - Add clearing deepspeed_config to force deepspeed to take config from args.deepspeed_configuration at initialize()
+### 1.10.0
+ - Updated scripts to cover MLPerf 3.0 submission.
+### 1.9.0
+ - Disabled auto dynamic shape support for Habana devices for PyTorch ResNet50.
+### 1.8.0
+- Prepared new scripts for PyTorch BERT data preprocessing.
+- Moved data preprocessing instructions to docker environment.
+### 1.7.0
+ - Updated scripts to cover MLPerf 2.1 submission.
+### 1.6.0
+- Removed obsolete files from TensorFlow/nlp/bert.
+### 1.5.0
+- Updated scripts to cover MLPerf 2.0 submission.
+- Cleaned up ResNet requirements compared to the originally submitted ones.
+- Removed run_bert_docker.sh and run_resnet50_docker.sh scripts.
+### 1.4.0
+- Switched from the deprecated TF_ENABLE_BF16_CONVERSION to TF_BF16_CONVERSION.
+- Added TF_ENABLE_DYNAMIC_SHAPES to MLPerf launchers.
+### 1.3.0
+- Updated requirements.txt file for BERT and ResNet.

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

@@ -0,0 +1,30 @@
+BSD 3-Clause License
+
+Copyright (c) 2021 Habana Labs, Ltd. an Intel Company
+Copyright (c) Soumith Chintala 2016,
+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 the copyright holder 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 AND CONTRIBUTORS "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 HOLDER 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.

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

@@ -0,0 +1,60 @@
+# Copyright 2018 MLBenchmark Group. 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) 2022 Habana Labs, Ltd. an Intel Company
+###############################################################################
+# List of changes:
+# - Added pytorch worker ranks using utils
+
+"""Convenience function for logging compliance tags to stdout.
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+
+import inspect
+import json
+import logging
+import os
+import re
+import sys
+import time
+import utils
+
+def get_mllog_mlloger(output_dir=None):
+    from mlperf_logging import mllog
+
+    if utils.get_rank() is not None:
+        str_worker_rank = str(utils.get_rank())
+    else:
+        str_worker_rank = "0"
+
+    mllogger = mllog.get_mllogger()
+    mllogger.propagate = False
+    mllog.propagate=False
+    if output_dir is None: output_dir='./log'
+    filenames = os.path.normpath(output_dir) + "/result_rank_" + str_worker_rank + ".txt"
+    mllog.config(filename=filenames)
+    workername = "worker" + str_worker_rank
+    mllog.config(
+            default_namespace = workername,
+            default_stack_offset = 1,
+            default_clear_line = False,
+            root_dir = os.path.normpath(
+           os.path.join(os.path.dirname(os.path.realpath(__file__)), "..", "..")))
+
+    return mllogger, mllog

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/implementations/HLS-Gaudi2-PT/PyTorch/mlperf_variable_map.json

@@ -0,0 +1,163 @@
+{
+    "conv1.weight": "conv0_weight",
+    "bn1.weight": "bn0_gamma",
+    "bn1.bias": "bn0_beta",
+    "layer1.0.conv1.weight": "stage1_unit1_conv1_weight",
+    "layer1.0.bn1.weight": "stage1_unit1_bn1_gamma",
+    "layer1.0.bn1.bias": "stage1_unit1_bn1_beta",
+    "layer1.0.conv2.weight": "stage1_unit1_conv2_weight",
+    "layer1.0.bn2.weight": "stage1_unit1_bn2_gamma",
+    "layer1.0.bn2.bias": "stage1_unit1_bn2_beta",
+    "layer1.0.conv3.weight": "stage1_unit1_conv3_weight",
+    "layer1.0.bn3.weight": "stage1_unit1_bn3_gamma",
+    "layer1.0.bn3.bias": "stage1_unit1_bn3_beta",
+    "layer1.0.downsample.0.weight": "stage1_unit1_conv1sc_weight",
+    "layer1.0.downsample.1.weight": "stage1_unit1_bnsc_gamma",
+    "layer1.0.downsample.1.bias": "stage1_unit1_bnsc_beta",
+    "layer1.1.conv1.weight": "stage1_unit2_conv1_weight",
+    "layer1.1.bn1.weight": "stage1_unit2_bn1_gamma",
+    "layer1.1.bn1.bias": "stage1_unit2_bn1_beta",
+    "layer1.1.conv2.weight": "stage1_unit2_conv2_weight",
+    "layer1.1.bn2.weight": "stage1_unit2_bn2_gamma",
+    "layer1.1.bn2.bias": "stage1_unit2_bn2_beta",
+    "layer1.1.conv3.weight": "stage1_unit2_conv3_weight",
+    "layer1.1.bn3.weight": "stage1_unit2_bn3_gamma",
+    "layer1.1.bn3.bias": "stage1_unit2_bn3_beta",
+    "layer1.2.conv1.weight": "stage1_unit3_conv1_weight",
+    "layer1.2.bn1.weight": "stage1_unit3_bn1_gamma",
+    "layer1.2.bn1.bias": "stage1_unit3_bn1_beta",
+    "layer1.2.conv2.weight": "stage1_unit3_conv2_weight",
+    "layer1.2.bn2.weight": "stage1_unit3_bn2_gamma",
+    "layer1.2.bn2.bias": "stage1_unit3_bn2_beta",
+    "layer1.2.conv3.weight": "stage1_unit3_conv3_weight",
+    "layer1.2.bn3.weight": "stage1_unit3_bn3_gamma",
+    "layer1.2.bn3.bias": "stage1_unit3_bn3_beta",
+    "layer2.0.conv1.weight": "stage2_unit1_conv1_weight",
+    "layer2.0.bn1.weight": "stage2_unit1_bn1_gamma",
+    "layer2.0.bn1.bias": "stage2_unit1_bn1_beta",
+    "layer2.0.conv2.weight": "stage2_unit1_conv2_weight",
+    "layer2.0.bn2.weight": "stage2_unit1_bn2_gamma",
+    "layer2.0.bn2.bias": "stage2_unit1_bn2_beta",
+    "layer2.0.conv3.weight": "stage2_unit1_conv3_weight",
+    "layer2.0.bn3.weight": "stage2_unit1_bn3_gamma",
+    "layer2.0.bn3.bias": "stage2_unit1_bn3_beta",
+    "layer2.0.downsample.0.weight": "stage2_unit1_conv1sc_weight",
+    "layer2.0.downsample.1.weight": "stage2_unit1_bnsc_gamma",
+    "layer2.0.downsample.1.bias": "stage2_unit1_bnsc_beta",
+    "layer2.1.conv1.weight": "stage2_unit2_conv1_weight",
+    "layer2.1.bn1.weight": "stage2_unit2_bn1_gamma",
+    "layer2.1.bn1.bias": "stage2_unit2_bn1_beta",
+    "layer2.1.conv2.weight": "stage2_unit2_conv2_weight",
+    "layer2.1.bn2.weight": "stage2_unit2_bn2_gamma",
+    "layer2.1.bn2.bias": "stage2_unit2_bn2_beta",
+    "layer2.1.conv3.weight": "stage2_unit2_conv3_weight",
+    "layer2.1.bn3.weight": "stage2_unit2_bn3_gamma",
+    "layer2.1.bn3.bias": "stage2_unit2_bn3_beta",
+    "layer2.2.conv1.weight": "stage2_unit3_conv1_weight",
+    "layer2.2.bn1.weight": "stage2_unit3_bn1_gamma",
+    "layer2.2.bn1.bias": "stage2_unit3_bn1_beta",
+    "layer2.2.conv2.weight": "stage2_unit3_conv2_weight",
+    "layer2.2.bn2.weight": "stage2_unit3_bn2_gamma",
+    "layer2.2.bn2.bias": "stage2_unit3_bn2_beta",
+    "layer2.2.conv3.weight": "stage2_unit3_conv3_weight",
+    "layer2.2.bn3.weight": "stage2_unit3_bn3_gamma",
+    "layer2.2.bn3.bias": "stage2_unit3_bn3_beta",
+    "layer2.3.conv1.weight": "stage2_unit4_conv1_weight",
+    "layer2.3.bn1.weight": "stage2_unit4_bn1_gamma",
+    "layer2.3.bn1.bias": "stage2_unit4_bn1_beta",
+    "layer2.3.conv2.weight": "stage2_unit4_conv2_weight",
+    "layer2.3.bn2.weight": "stage2_unit4_bn2_gamma",
+    "layer2.3.bn2.bias": "stage2_unit4_bn2_beta",
+    "layer2.3.conv3.weight": "stage2_unit4_conv3_weight",
+    "layer2.3.bn3.weight": "stage2_unit4_bn3_gamma",
+    "layer2.3.bn3.bias": "stage2_unit4_bn3_beta",
+    "layer3.0.conv1.weight": "stage3_unit1_conv1_weight",
+    "layer3.0.bn1.weight": "stage3_unit1_bn1_gamma",
+    "layer3.0.bn1.bias": "stage3_unit1_bn1_beta",
+    "layer3.0.conv2.weight": "stage3_unit1_conv2_weight",
+    "layer3.0.bn2.weight": "stage3_unit1_bn2_gamma",
+    "layer3.0.bn2.bias": "stage3_unit1_bn2_beta",
+    "layer3.0.conv3.weight": "stage3_unit1_conv3_weight",
+    "layer3.0.bn3.weight": "stage3_unit1_bn3_gamma",
+    "layer3.0.bn3.bias": "stage3_unit1_bn3_beta",
+    "layer3.0.downsample.0.weight": "stage3_unit1_conv1sc_weight",
+    "layer3.0.downsample.1.weight": "stage3_unit1_bnsc_gamma",
+    "layer3.0.downsample.1.bias": "stage3_unit1_bnsc_beta",
+    "layer3.1.conv1.weight": "stage3_unit2_conv1_weight",
+    "layer3.1.bn1.weight": "stage3_unit2_bn1_gamma",
+    "layer3.1.bn1.bias": "stage3_unit2_bn1_beta",
+    "layer3.1.conv2.weight": "stage3_unit2_conv2_weight",
+    "layer3.1.bn2.weight": "stage3_unit2_bn2_gamma",
+    "layer3.1.bn2.bias": "stage3_unit2_bn2_beta",
+    "layer3.1.conv3.weight": "stage3_unit2_conv3_weight",
+    "layer3.1.bn3.weight": "stage3_unit2_bn3_gamma",
+    "layer3.1.bn3.bias": "stage3_unit2_bn3_beta",
+    "layer3.2.conv1.weight": "stage3_unit3_conv1_weight",
+    "layer3.2.bn1.weight": "stage3_unit3_bn1_gamma",
+    "layer3.2.bn1.bias": "stage3_unit3_bn1_beta",
+    "layer3.2.conv2.weight": "stage3_unit3_conv2_weight",
+    "layer3.2.bn2.weight": "stage3_unit3_bn2_gamma",
+    "layer3.2.bn2.bias": "stage3_unit3_bn2_beta",
+    "layer3.2.conv3.weight": "stage3_unit3_conv3_weight",
+    "layer3.2.bn3.weight": "stage3_unit3_bn3_gamma",
+    "layer3.2.bn3.bias": "stage3_unit3_bn3_beta",
+    "layer3.3.conv1.weight": "stage3_unit4_conv1_weight",
+    "layer3.3.bn1.weight": "stage3_unit4_bn1_gamma",
+    "layer3.3.bn1.bias": "stage3_unit4_bn1_beta",
+    "layer3.3.conv2.weight": "stage3_unit4_conv2_weight",
+    "layer3.3.bn2.weight": "stage3_unit4_bn2_gamma",
+    "layer3.3.bn2.bias": "stage3_unit4_bn2_beta",
+    "layer3.3.conv3.weight": "stage3_unit4_conv3_weight",
+    "layer3.3.bn3.weight": "stage3_unit4_bn3_gamma",
+    "layer3.3.bn3.bias": "stage3_unit4_bn3_beta",
+    "layer3.4.conv1.weight": "stage3_unit5_conv1_weight",
+    "layer3.4.bn1.weight": "stage3_unit5_bn1_gamma",
+    "layer3.4.bn1.bias": "stage3_unit5_bn1_beta",
+    "layer3.4.conv2.weight": "stage3_unit5_conv2_weight",
+    "layer3.4.bn2.weight": "stage3_unit5_bn2_gamma",
+    "layer3.4.bn2.bias": "stage3_unit5_bn2_beta",
+    "layer3.4.conv3.weight": "stage3_unit5_conv3_weight",
+    "layer3.4.bn3.weight": "stage3_unit5_bn3_gamma",
+    "layer3.4.bn3.bias": "stage3_unit5_bn3_beta",
+    "layer3.5.conv1.weight": "stage3_unit6_conv1_weight",
+    "layer3.5.bn1.weight": "stage3_unit6_bn1_gamma",
+    "layer3.5.bn1.bias": "stage3_unit6_bn1_beta",
+    "layer3.5.conv2.weight": "stage3_unit6_conv2_weight",
+    "layer3.5.bn2.weight": "stage3_unit6_bn2_gamma",
+    "layer3.5.bn2.bias": "stage3_unit6_bn2_beta",
+    "layer3.5.conv3.weight": "stage3_unit6_conv3_weight",
+    "layer3.5.bn3.weight": "stage3_unit6_bn3_gamma",
+    "layer3.5.bn3.bias": "stage3_unit6_bn3_beta",
+    "layer4.0.conv1.weight": "stage4_unit1_conv1_weight",
+    "layer4.0.bn1.weight": "stage4_unit1_bn1_gamma",
+    "layer4.0.bn1.bias": "stage4_unit1_bn1_beta",
+    "layer4.0.conv2.weight": "stage4_unit1_conv2_weight",
+    "layer4.0.bn2.weight": "stage4_unit1_bn2_gamma",
+    "layer4.0.bn2.bias": "stage4_unit1_bn2_beta",
+    "layer4.0.conv3.weight": "stage4_unit1_conv3_weight",
+    "layer4.0.bn3.weight": "stage4_unit1_bn3_gamma",
+    "layer4.0.bn3.bias": "stage4_unit1_bn3_beta",
+    "layer4.0.downsample.0.weight": "stage4_unit1_conv1sc_weight",
+    "layer4.0.downsample.1.weight": "stage4_unit1_bnsc_gamma",
+    "layer4.0.downsample.1.bias": "stage4_unit1_bnsc_beta",
+    "layer4.1.conv1.weight": "stage4_unit2_conv1_weight",
+    "layer4.1.bn1.weight": "stage4_unit2_bn1_gamma",
+    "layer4.1.bn1.bias": "stage4_unit2_bn1_beta",
+    "layer4.1.conv2.weight": "stage4_unit2_conv2_weight",
+    "layer4.1.bn2.weight": "stage4_unit2_bn2_gamma",
+    "layer4.1.bn2.bias": "stage4_unit2_bn2_beta",
+    "layer4.1.conv3.weight": "stage4_unit2_conv3_weight",
+    "layer4.1.bn3.weight": "stage4_unit2_bn3_gamma",
+    "layer4.1.bn3.bias": "stage4_unit2_bn3_beta",
+    "layer4.2.conv1.weight": "stage4_unit3_conv1_weight",
+    "layer4.2.bn1.weight": "stage4_unit3_bn1_gamma",
+    "layer4.2.bn1.bias": "stage4_unit3_bn1_beta",
+    "layer4.2.conv2.weight": "stage4_unit3_conv2_weight",
+    "layer4.2.bn2.weight": "stage4_unit3_bn2_gamma",
+    "layer4.2.bn2.bias": "stage4_unit3_bn2_beta",
+    "layer4.2.conv3.weight": "stage4_unit3_conv3_weight",
+    "layer4.2.bn3.weight": "stage4_unit3_bn3_gamma",
+    "layer4.2.bn3.bias": "stage4_unit3_bn3_beta",
+    "fc.weight": "fc1_weight",
+    "fc.bias": "fc1_bias"
+}

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

@@ -0,0 +1,59 @@
+# Copyright (C) 2022 Habana Labs, Ltd. an Intel Company
+
+import torch
+from torch.optim.lr_scheduler import _LRScheduler
+
+class PolynomialDecayWithWarmup(_LRScheduler):
+    """Polynomial learning rate decay until step reach to max_decay_step
+
+    Args
+        optimizer (Optimizer): Wrapped optimizer.
+        max_decay_steps: after this step, we stop decreasing learning rate
+        end_learning_rate: scheduler stoping learning rate decay, value of learning rate must be this value
+        power: The power of the polynomial.
+    """
+
+    def __init__(self, optimizer, batch_size, steps_per_epoch, train_steps, initial_learning_rate=9.0, warmup_epochs=3,
+                 end_learning_rate=0.0001, power=2.0, lars_decay_epochs=36, mlperf_mlloger=None, mlperf_mllog=None, opt_name=None):
+        self.last_step = 0
+        self.steps_per_epoch = steps_per_epoch
+        self.train_steps = train_steps
+        self.initial_learning_rate = initial_learning_rate
+        self.warmup_epochs = warmup_epochs
+        self.end_learning_rate = end_learning_rate
+        self.power = power
+        self.warmup_steps = warmup_epochs * (steps_per_epoch - 1)
+        self.decay_steps = lars_decay_epochs * (steps_per_epoch - 1) - self.warmup_steps + 1
+        self.opt_name = opt_name.lower()
+
+        mlperf_mlloger.event(key=mlperf_mllog.constants.LARS_OPT_END_LR, value=self.end_learning_rate)
+        mlperf_mlloger.event(key=mlperf_mllog.constants.LARS_OPT_LR_DECAY_STEPS, value=int(self.decay_steps))
+        mlperf_mlloger.event(key=mlperf_mllog.constants.LARS_OPT_LR_DECAY_POLY_POWER, value=power)
+        mlperf_mlloger.event(key=self.opt_name+'_'+mlperf_mllog.constants.OPT_LR_WARMUP_EPOCHS, value=float(self.warmup_epochs))
+        mlperf_mlloger.event(key=self.opt_name+'_'+mlperf_mllog.constants.OPT_BASE_LR, value=self.initial_learning_rate)
+
+        super().__init__(optimizer)
+
+    def get_lr(self):
+        warmup_steps = self.warmup_steps
+        warmup_rate = (
+            self.initial_learning_rate * self.last_step / warmup_steps)
+
+        poly_steps = self.last_step - warmup_steps
+        poly_steps = poly_steps if poly_steps > 1 else 1
+
+        poly_rate = (self.initial_learning_rate - self.end_learning_rate) * \
+            ((1 - poly_steps / self.decay_steps) **
+             (self.power)) + self.end_learning_rate
+
+        decay_rate = warmup_rate if self.last_step <= warmup_steps else poly_rate
+        return decay_rate
+
+    def step(self, step=None):
+        if step is None:
+            step = self.last_step + 1
+        self.last_step = step if step != 0 else 1
+        if self.last_step <= self.decay_steps + self.warmup_steps:
+            decay_lrs = [self.get_lr()]
+            for param_group, lr in zip(self.optimizer.param_groups, decay_lrs):
+                param_group['lr'] = lr

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

@@ -0,0 +1,369 @@
+# Copyright (c) 2022, Habana Labs Ltd.  All rights reserved.
+
+import torch
+import torch.nn as nn
+from .utils import load_state_dict_from_url
+
+
+__all__ = ['ResNet', 'resnet18', 'resnet34', 'resnet50', 'resnet101',
+           'resnet152', 'resnext50_32x4d', 'resnext101_32x4d', 'resnext101_32x8d',
+           'wide_resnet50_2', 'wide_resnet101_2']
+
+
+model_urls = {
+    'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
+    'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
+    'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
+    'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
+    'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
+    'resnext50_32x4d': 'https://download.pytorch.org/models/resnext50_32x4d-7cdf4587.pth',
+    'resnext101_32x8d': 'https://download.pytorch.org/models/resnext101_32x8d-8ba56ff5.pth',
+    'wide_resnet50_2': 'https://download.pytorch.org/models/wide_resnet50_2-95faca4d.pth',
+    'wide_resnet101_2': 'https://download.pytorch.org/models/wide_resnet101_2-32ee1156.pth',
+}
+
+
+def conv3x3(in_planes, out_planes, stride=1, groups=1, dilation=1):
+    """3x3 convolution with padding"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
+                     padding=dilation, groups=groups, bias=False, dilation=dilation)
+
+
+def conv1x1(in_planes, out_planes, stride=1):
+    """1x1 convolution"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)
+
+
+class BasicBlock(nn.Module):
+    expansion = 1
+    __constants__ = ['downsample']
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,
+                 base_width=64, dilation=1, norm_layer=None):
+        super(BasicBlock, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        if groups != 1 or base_width != 64:
+            raise ValueError('BasicBlock only supports groups=1 and base_width=64')
+        if dilation > 1:
+            raise NotImplementedError("Dilation > 1 not supported in BasicBlock")
+        # Both self.conv1 and self.downsample layers downsample the input when stride != 1
+        self.conv1 = conv3x3(inplanes, planes, stride)
+        self.bn1 = norm_layer(planes)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = conv3x3(planes, planes)
+        self.bn2 = norm_layer(planes)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        identity = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out = out + identity
+        out = self.relu(out)
+
+        return out
+
+
+class Bottleneck(nn.Module):
+    expansion = 4
+    __constants__ = ['downsample']
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,
+                 base_width=64, dilation=1, norm_layer=None):
+        super(Bottleneck, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        width = int(planes * (base_width / 64.)) * groups
+        # Both self.conv2 and self.downsample layers downsample the input when stride != 1
+        self.conv1 = conv1x1(inplanes, width)
+        self.bn1 = norm_layer(width)
+        self.conv2 = conv3x3(width, width, stride, groups, dilation)
+        self.bn2 = norm_layer(width)
+        self.conv3 = conv1x1(width, planes * self.expansion)
+        self.bn3 = norm_layer(planes * self.expansion)
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        identity = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out = out + identity
+        out = self.relu(out)
+
+        return out
+
+
+class ResNet(nn.Module):
+
+    def __init__(self, block, layers, num_classes=1000, zero_init_residual=False,
+                 groups=1, width_per_group=64, replace_stride_with_dilation=None,
+                 norm_layer=None):
+        super(ResNet, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        self._norm_layer = norm_layer
+
+        self.inplanes = 64
+        self.dilation = 1
+        if replace_stride_with_dilation is None:
+            # each element in the tuple indicates if we should replace
+            # the 2x2 stride with a dilated convolution instead
+            replace_stride_with_dilation = [False, False, False]
+        if len(replace_stride_with_dilation) != 3:
+            raise ValueError("replace_stride_with_dilation should be None "
+                             "or a 3-element tuple, got {}".format(replace_stride_with_dilation))
+        self.groups = groups
+        self.base_width = width_per_group
+        self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3,
+                               bias=False)
+        self.bn1 = norm_layer(self.inplanes)
+        self.relu = nn.ReLU(inplace=True)
+        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.layer1 = self._make_layer(block, 64, layers[0])
+        self.layer2 = self._make_layer(block, 128, layers[1], stride=2,
+                                       dilate=replace_stride_with_dilation[0])
+        self.layer3 = self._make_layer(block, 256, layers[2], stride=2,
+                                       dilate=replace_stride_with_dilation[1])
+        self.layer4 = self._make_layer(block, 512, layers[3], stride=2,
+                                       dilate=replace_stride_with_dilation[2])
+        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
+
+        self.fc = nn.Linear(512 * block.expansion, num_classes)
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+        # Zero-initialize the last BN in each residual branch,
+        # so that the residual branch starts with zeros, and each residual block behaves like an identity.
+        # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677
+        if zero_init_residual:
+            for m in self.modules():
+                if isinstance(m, Bottleneck):
+                    nn.init.constant_(m.bn3.weight, 0)
+                elif isinstance(m, BasicBlock):
+                    nn.init.constant_(m.bn2.weight, 0)
+
+    def _make_layer(self, block, planes, blocks, stride=1, dilate=False):
+        norm_layer = self._norm_layer
+        downsample = None
+        previous_dilation = self.dilation
+        if dilate:
+            self.dilation *= stride
+            stride = 1
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                conv1x1(self.inplanes, planes * block.expansion, stride),
+                norm_layer(planes * block.expansion),
+            )
+
+        layers = []
+        layers.append(block(self.inplanes, planes, stride, downsample, self.groups,
+                            self.base_width, previous_dilation, norm_layer))
+        self.inplanes = planes * block.expansion
+        for _ in range(1, blocks):
+            layers.append(block(self.inplanes, planes, groups=self.groups,
+                                base_width=self.base_width, dilation=self.dilation,
+                                norm_layer=norm_layer))
+
+        return nn.Sequential(*layers)
+
+    def _forward_impl(self, x):
+        # See note [TorchScript super()]
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.maxpool(x)
+
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.layer4(x)
+
+        x = self.avgpool(x)
+        x = torch.flatten(x, 1)
+        x = self.fc(x)
+
+        return x
+
+    def forward(self, x):
+        return self._forward_impl(x)
+
+
+def _resnet(arch, block, layers, pretrained, progress, **kwargs):
+    model = ResNet(block, layers, **kwargs)
+    if pretrained:
+        state_dict = load_state_dict_from_url(model_urls[arch],
+                                              progress=progress)
+        model.load_state_dict(state_dict)
+    return model
+
+
+def resnet18(pretrained=False, progress=True, **kwargs):
+    r"""ResNet-18 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet18', BasicBlock, [2, 2, 2, 2], pretrained, progress,
+                   **kwargs)
+
+
+def resnet34(pretrained=False, progress=True, **kwargs):
+    r"""ResNet-34 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet34', BasicBlock, [3, 4, 6, 3], pretrained, progress,
+                   **kwargs)
+
+
+def resnet50(pretrained=False, progress=True, **kwargs):
+    r"""ResNet-50 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet50', Bottleneck, [3, 4, 6, 3], pretrained, progress,
+                   **kwargs)
+
+
+def resnet101(pretrained=False, progress=True, **kwargs):
+    r"""ResNet-101 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet101', Bottleneck, [3, 4, 23, 3], pretrained, progress,
+                   **kwargs)
+
+
+def resnet152(pretrained=False, progress=True, **kwargs):
+    r"""ResNet-152 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet152', Bottleneck, [3, 8, 36, 3], pretrained, progress,
+                   **kwargs)
+
+
+def resnext50_32x4d(pretrained=False, progress=True, **kwargs):
+    r"""ResNeXt-50 32x4d model from
+    `"Aggregated Residual Transformation for Deep Neural Networks" <https://arxiv.org/pdf/1611.05431.pdf>`_
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    kwargs['groups'] = 32
+    kwargs['width_per_group'] = 4
+    return _resnet('resnext50_32x4d', Bottleneck, [3, 4, 6, 3],
+                   pretrained, progress, **kwargs)
+
+
+def resnext101_32x4d(pretrained=False, progress=True, **kwargs):
+    r"""ResNeXt-101 32x4d model from
+    `"Aggregated Residual Transformation for Deep Neural Networks" <https://arxiv.org/pdf/1611.05431.pdf>`_
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    if pretrained:
+        raise AssertionError("Pretrained models are not available for resnext101_32x4d")
+
+    kwargs['groups'] = 32
+    kwargs['width_per_group'] = 4
+    return _resnet('resnext101_32x4d', Bottleneck, [3, 4, 23, 3],
+                   pretrained, progress, **kwargs)
+
+
+def resnext101_32x8d(pretrained=False, progress=True, **kwargs):
+    r"""ResNeXt-101 32x8d model from
+    `"Aggregated Residual Transformation for Deep Neural Networks" <https://arxiv.org/pdf/1611.05431.pdf>`_
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    kwargs['groups'] = 32
+    kwargs['width_per_group'] = 8
+    return _resnet('resnext101_32x8d', Bottleneck, [3, 4, 23, 3],
+                   pretrained, progress, **kwargs)
+
+
+def wide_resnet50_2(pretrained=False, progress=True, **kwargs):
+    r"""Wide ResNet-50-2 model from
+    `"Wide Residual Networks" <https://arxiv.org/pdf/1605.07146.pdf>`_
+
+    The model is the same as ResNet except for the bottleneck number of channels
+    which is twice larger in every block. The number of channels in outer 1x1
+    convolutions is the same, e.g. last block in ResNet-50 has 2048-512-2048
+    channels, and in Wide ResNet-50-2 has 2048-1024-2048.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    kwargs['width_per_group'] = 64 * 2
+    return _resnet('wide_resnet50_2', Bottleneck, [3, 4, 6, 3],
+                   pretrained, progress, **kwargs)
+
+
+def wide_resnet101_2(pretrained=False, progress=True, **kwargs):
+    r"""Wide ResNet-101-2 model from
+    `"Wide Residual Networks" <https://arxiv.org/pdf/1605.07146.pdf>`_
+
+    The model is the same as ResNet except for the bottleneck number of channels
+    which is twice larger in every block. The number of channels in outer 1x1
+    convolutions is the same, e.g. last block in ResNet-50 has 2048-512-2048
+    channels, and in Wide ResNet-50-2 has 2048-1024-2048.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    kwargs['width_per_group'] = 64 * 2
+    return _resnet('wide_resnet101_2', Bottleneck, [3, 4, 23, 3],
+                   pretrained, progress, **kwargs)

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/implementations/HLS-Gaudi2-PT/PyTorch/ops_bf16_Resnet.txt

@@ -0,0 +1,11 @@
+addmm
+avg_pool2d
+bmm
+conv2d
+dot
+max_pool2d
+mm
+mv
+relu
+t
+linear

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/implementations/HLS-Gaudi2-PT/PyTorch/ops_fp32_Resnet.txt

@@ -0,0 +1,5 @@
+cross_entropy_loss
+log_softmax
+nll_loss
+softmax
+topk

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/implementations/HLS-Gaudi2-PT/PyTorch/requirements.txt

@@ -0,0 +1,4 @@
+mpi4py>=3.0.3
+scipy>=1.7.1
+colorlog==6.6.0
+git+https://github.com/mlperf/[email protected]

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

@@ -0,0 +1,815 @@
+# Copyright (c) 2021-2023, Habana Labs Ltd.  All rights reserved.
+
+
+from __future__ import print_function
+import copy
+from math import ceil
+import shutil
+import uuid
+
+# Import local copy of the model only for ResNext101_32x4d
+# which is not part of standard torchvision package.
+import model as resnet_models
+import datetime
+import os
+import time
+import sys
+import json
+
+import torch
+import torch.utils.data
+from torch import nn
+import torchvision
+from torchvision import transforms
+import random
+import utils
+import habana_frameworks.torch.core as htcore
+import habana_dataloader
+from mlp_log import get_mllog_mlloger
+
+try:
+    from apex import amp
+except ImportError:
+    amp = None
+
+DEFAULT_IMAGE_SIZE = 224
+NUM_CHANNELS = 3
+
+def get_mlperf_variable_map():
+    try:
+        script_path = os.path.realpath(__file__)
+        head_tail = os.path.split(script_path)
+        mlperf_map_file = head_tail[0] + '/mlperf_variable_map.json'
+        with open(mlperf_map_file, mode='r') as file_handle:
+            json_content = file_handle.read()
+            mlperf_map = json.loads(json_content)
+    except IOError:
+      raise IOError(f"MLPerf variable map file: {mlperf_map_file} not accesible")
+    return mlperf_map
+
+
+def train_one_epoch(lr_scheduler, model, criterion, optimizer, data_loader, device, epoch,
+                    print_freq, args, apex=False, warmup=False):
+    model.train()
+    metric_logger = utils.MetricLogger(delimiter="  ", device=device)
+    metric_logger.add_meter('lr', utils.SmoothedValue(window_size=1, fmt='{value}'))
+    metric_logger.add_meter('img/s', utils.SmoothedValue(window_size=10, fmt='{value}'))
+
+    header = f'Warmup epoch: [{epoch}]' if warmup else f'Epoch: [{epoch}]'
+    step_count = 0
+    last_print_time = time.time()
+
+    profiler = None
+    if args.profile_steps is not None and not warmup:
+        profile_steps = [int(i) for i in args.profile_steps.split(',')]
+        profiling_duration = profile_steps[1] - profile_steps[0]
+        profiler = torch.profiler.profile(
+            activities=[torch.profiler.ProfilerActivity.CPU, torch.profiler.ProfilerActivity.HPU],
+            schedule=torch.profiler.schedule(wait=0, warmup=profile_steps[0], active=profiling_duration, repeat=1),
+            on_trace_ready=torch.profiler.tensorboard_trace_handler(args.output_dir,
+                                                                    worker_name=f"worker_{utils.get_rank()}",
+                                                                    use_gzip=True),
+            record_shapes=True,
+            with_stack=True)
+        profiler.start()
+
+    for image, target in metric_logger.log_every(data_loader, print_freq, header):
+        image, target = image.to(device, non_blocking=True), target.to(device, non_blocking=True)
+        dl_ex_start_time = time.time()
+        if args.channels_last:
+            image = image.contiguous(memory_format=torch.channels_last)
+
+        with torch.autocast(device_type="hpu", dtype=torch.bfloat16, enabled=args.use_autocast):
+            output = model(image)
+            loss = criterion(output, target)
+            loss = loss / image.shape[0]
+        optimizer.zero_grad(set_to_none=True)
+
+        if apex:
+            with amp.scale_loss(loss, optimizer) as scaled_loss:
+                scaled_loss.backward()
+        else:
+            loss.backward()
+
+        if args.run_lazy_mode and not args.use_torch_compile:
+            htcore.mark_step()
+
+        optimizer.step()
+
+        if args.run_lazy_mode and not args.use_torch_compile:
+            htcore.mark_step()
+
+        if step_count % print_freq == 0:
+            output_cpu = output.detach().to('cpu')
+            acc1, acc5 = utils.accuracy(output_cpu, target, topk=(1, 5))
+            batch_size = image.shape[0]
+            metric_logger.update(loss=loss.item(), lr=optimizer.param_groups[0]["lr"])
+            metric_logger.meters['acc1'].update(acc1.item(), n=batch_size * print_freq)
+            metric_logger.meters['acc5'].update(acc5.item(), n=batch_size * print_freq)
+            current_time = time.time()
+            last_print_time = dl_ex_start_time if args.dl_time_exclude else last_print_time
+            images_processed = batch_size * print_freq if step_count != 0 else batch_size
+            metric_logger.meters['img/s'].update(images_processed / (current_time - last_print_time))
+            last_print_time = time.time()
+
+        step_count = step_count + 1
+        if profiler is not None:
+            profiler.step()
+
+        if step_count >= args.num_train_steps:
+            break
+
+        if lr_scheduler is not None:
+            lr_scheduler.step()
+
+    if profiler is not None:
+        profiler.stop()
+
+
+def evaluate(model, criterion, data_loader, device, print_freq=100, warmup=False):
+    model.eval()
+    metric_logger = utils.MetricLogger(delimiter="  ", device=device)
+    header = 'Warmup test:' if warmup else 'Test:'
+    step_count = 0
+    with torch.no_grad():
+        for image, target in metric_logger.log_every(data_loader, print_freq, header):
+            image = image.to(device, non_blocking=True)
+
+            if args.channels_last:
+                image = image.contiguous(memory_format=torch.channels_last)
+
+            target = target.to(device, non_blocking=True)
+            with torch.autocast(device_type="hpu", dtype=torch.bfloat16, enabled=args.use_autocast):
+                output = model(image)
+                loss = criterion(output, target)
+                loss = loss / image.shape[0]
+
+            acc1, acc5 = utils.accuracy(output, target, topk=(1, 5))
+            # FIXME need to take into account that the datasets
+            # could have been padded in distributed setup
+            batch_size = image.shape[0]
+            loss_cpu = loss.to('cpu').detach()
+            metric_logger.update(loss=loss_cpu.item())
+            metric_logger.meters['acc1'].update(acc1.item(), n=batch_size)
+            metric_logger.meters['acc5'].update(acc5.item(), n=batch_size)
+            step_count = step_count + 1
+            if step_count >= args.num_eval_steps:
+                break
+    # gather the stats from all processes
+    metric_logger.synchronize_between_processes()
+
+    # Return from here if evaluation phase does not go through any iterations.(eg, The data set is so small that
+    # there is only one eval batch, but that was skipped in data loader due to drop_last=True)
+    if len(metric_logger.meters) == 0:
+        return
+
+    print(' * Acc@1 {top1.global_avg:.3f} Acc@5 {top5.global_avg:.3f}'
+          .format(top1=metric_logger.acc1, top5=metric_logger.acc5))
+    return metric_logger.acc1.global_avg
+
+
+def _get_cache_path(filepath):
+    import hashlib
+    h = hashlib.sha1(filepath.encode()).hexdigest()
+    cache_path = os.path.join("~", ".torch", "vision", "datasets", "imagefolder", h[:10] + ".pt")
+    cache_path = os.path.expanduser(cache_path)
+    return cache_path
+
+def warmup(model_for_train, model_for_eval, device, criterion, optimizer, args, data_loader_type, pin_memory_device, pin_memory):
+    state_backup = copy.deepcopy(optimizer.optim.state)
+    dataset, dataset_test, train_sampler, test_sampler = load_data(f'{args.output_dir}/resnet_synth_data/train', f'{args.output_dir}/resnet_synth_data/val', args=args, synthetic=True)
+    data_loader = data_loader_type(
+        dataset, args.batch_size, sampler=train_sampler,
+        num_workers=args.workers, pin_memory=pin_memory, pin_memory_device=pin_memory_device)
+    data_loader_test = data_loader_type(
+        dataset_test, args.batch_size, sampler=test_sampler,
+        num_workers=args.workers, pin_memory=pin_memory, pin_memory_device=pin_memory_device)
+    train_one_epoch(None, model_for_train, criterion, optimizer, data_loader, device, 0,
+                    1, args, apex=args.apex, warmup=True)
+    evaluate(model_for_eval, criterion, data_loader_test, device, print_freq=1, warmup=True)
+    optimizer.zero_grad(True)
+    optimizer.optim.state = state_backup
+    optimizer.state = optimizer.optim.__getstate__()['state']
+
+def load_data(traindir, valdir, args, manifest=None, synthetic=False):
+    # Data loading code
+    print("Loading data")
+    normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                                     std=[0.229, 0.224, 0.225])
+    dataset_transforms = transforms.Compose([
+                transforms.RandomResizedCrop(224),
+                transforms.RandomHorizontalFlip(),
+                transforms.ToTensor(),
+                normalize,
+            ])
+    dataset_test_transforms = transforms.Compose([
+                transforms.Resize(256),
+                transforms.CenterCrop(224),
+                transforms.ToTensor(),
+                normalize,
+            ])
+    dataset_loader_train = habana_dataloader.habana_dataset.ImageFolderWithManifest if args.dl_worker_type == "HABANA" and not synthetic else torchvision.datasets.ImageFolder
+    dataset_loader_eval = torchvision.datasets.ImageFolder
+    loader_params = {'root': traindir, 'transform': dataset_transforms}
+    loader_test_params = {'root': valdir, 'transform': dataset_test_transforms}
+    if args.dl_worker_type == "HABANA" and not synthetic:
+        loader_params['manifest'] = manifest
+    if (synthetic):
+        steps = 4
+        size = steps*args.batch_size
+        img_shape = (NUM_CHANNELS, DEFAULT_IMAGE_SIZE, DEFAULT_IMAGE_SIZE)
+        all_images_shape = (size, NUM_CHANNELS, DEFAULT_IMAGE_SIZE, DEFAULT_IMAGE_SIZE)
+        chunks = torch.ones(all_images_shape, dtype=torch.uint8).chunk(size)
+        images = [img.reshape(img_shape) for img in chunks]
+        for i, image in enumerate(images):
+            if (i % args.batch_size == 0):
+                batch_class_name = uuid.uuid4()
+                utils.mkdir(f'{traindir}/{batch_class_name}')
+                utils.mkdir(f'{valdir}/{batch_class_name}')
+            torchvision.io.write_jpeg(image, f'{traindir}/{batch_class_name}/{i}.JPEG')
+            torchvision.io.write_jpeg(image, f'{valdir}/{batch_class_name}/{i}.JPEG')
+
+    print("Loading training data")
+    st = time.time()
+    cache_path = _get_cache_path(traindir)
+    cache_dataset = args.cache_dataset and not synthetic
+    if cache_dataset and os.path.exists(cache_path):
+        # Attention, as the transforms are also cached!
+        print("Loading dataset_train from {}".format(cache_path))
+        dataset, _ = torch.load(cache_path)
+    else:
+        dataset = dataset_loader_train(**loader_params)
+        if cache_dataset:
+            print("Saving dataset_train to {}".format(cache_path))
+            utils.mkdir(os.path.dirname(cache_path))
+            utils.save_on_master((dataset, traindir), cache_path)
+    print("Took", time.time() - st)
+
+    print("Loading validation data")
+    cache_path = _get_cache_path(valdir)
+    if cache_dataset and os.path.exists(cache_path):
+        # Attention, as the transforms are also cached!
+        print("Loading dataset_test from {}".format(cache_path))
+        dataset_test, _ = torch.load(cache_path)
+    else:
+        dataset_test = dataset_loader_eval(**loader_test_params)
+        if cache_dataset:
+            print("Saving dataset_test to {}".format(cache_path))
+            utils.mkdir(os.path.dirname(cache_path))
+            utils.save_on_master((dataset_test, valdir), cache_path)
+
+    print("Creating data loaders")
+    if args.distributed:
+        train_sampler = torch.utils.data.distributed.DistributedSampler(dataset)
+        test_sampler = torch.utils.data.distributed.DistributedSampler(dataset_test)
+    else:
+        train_sampler = torch.utils.data.RandomSampler(dataset)
+        test_sampler = torch.utils.data.SequentialSampler(dataset_test)
+
+    return dataset, dataset_test, train_sampler, test_sampler
+
+
+def lr_vec_fcn(values, milestones):
+    lr_vec = []
+    for n in range(len(milestones) - 1):
+        lr_vec += [values[n]] * (milestones[n + 1] - milestones[n])
+    return lr_vec
+
+
+def adjust_learning_rate(optimizer, epoch, lr_vec):
+    """Sets the learning rate to the initial LR decayed by 10 every 30 epochs"""
+    lr = lr_vec[epoch]
+    for param_group in optimizer.param_groups:
+        param_group['lr'] = lr
+
+
+def main(args):
+
+    if args.eval_offset_epochs < 0:
+        assert False, "Eval offset has to be 0 or bigger"
+
+    if args.epochs_between_evals < 1:
+        assert False, "Epochs between evaluations has to be 1 or bigger"
+
+    if args.dl_worker_type == "MP":
+        try:
+            # Default 'fork' doesn't work with synapse. Use 'forkserver' or 'spawn'
+            torch.multiprocessing.set_start_method('spawn')
+        except RuntimeError:
+            pass
+    elif args.dl_worker_type == "HABANA":
+        try:
+            import habana_dataloader
+        except ImportError:
+            assert False, "Could Not import habana dataloader package"
+
+    if args.device == 'hpu':
+        if args.run_lazy_mode:
+            assert os.getenv('PT_HPU_LAZY_MODE') == '1', f"run-lazy-mode == True, but PT_HPU_LAZY_MODE={os.getenv('PT_HPU_LAZY_MODE')}"
+        else:
+            assert os.getenv('PT_HPU_LAZY_MODE') == '0' or os.getenv('PT_HPU_LAZY_MODE')== '2', f"args.use_lazy_mode == False, but PT_HPU_LAZY_MODE={os.getenv('PT_HPU_LAZY_MODE')}"
+
+        if args.run_lazy_mode and not args.use_torch_compile:
+            try:
+                import habana_frameworks.torch.hpu as hthpu
+                hthpu.enable_dynamic_shape()
+            except ImportError:
+                logger.info("habana_frameworks could not be loaded")
+
+    if args.apex:
+        if sys.version_info < (3, 0):
+            raise RuntimeError(
+                "Apex currently only supports Python 3. Aborting.")
+        if amp is None:
+            raise RuntimeError("Failed to import apex. Please install apex from https://www.github.com/nvidia/apex "
+                               "to enable mixed-precision training.")
+
+    utils.init_distributed_mode(args)
+    print(args)
+
+    synth_data_dir = (args.output_dir if args.output_dir else '/tmp') + '/resnet_synth_data'
+
+    if utils.get_rank() == 0:
+        if args.output_dir:
+            utils.mkdir(args.output_dir)
+        if args.log_dir:
+            utils.mkdir(args.log_dir)
+
+        try:
+            shutil.rmtree(synth_data_dir)
+        except:
+            pass
+
+        utils.mkdir(f'{synth_data_dir}')
+        utils.mkdir(f'{synth_data_dir}/train')
+        utils.mkdir(f'{synth_data_dir}/val')
+
+    if utils.get_world_size() > 1:
+        utils.barrier()
+
+    mlperf_mlloger, mlperf_mllog = get_mllog_mlloger(args.log_dir if args.log_dir else args.output_dir)
+    mlperf_mlloger.event(key=mlperf_mllog.constants.CACHE_CLEAR, value=True)
+    mlperf_mlloger.start(key=mlperf_mllog.constants.INIT_START, value=None)
+    mlperf_mlloger.event(key=mlperf_mllog.constants.SUBMISSION_BENCHMARK, value=mlperf_mllog.constants.RESNET)
+    mlperf_mlloger.event(key=mlperf_mllog.constants.SUBMISSION_ORG, value='Habana')
+    mlperf_mlloger.event(key=mlperf_mllog.constants.SUBMISSION_DIVISION, value='closed')
+    mlperf_mlloger.event(key=mlperf_mllog.constants.SUBMISSION_PLATFORM, value='gaudi-{}'.format(args.num_gpus))
+    mlperf_mlloger.event(key=mlperf_mllog.constants.SUBMISSION_STATUS, value='onprem')
+
+    device = torch.device(args.device)
+
+    torch.backends.cudnn.benchmark = True
+
+    if args.device == 'hpu' and utils.get_world_size() > 0:
+        # patch torch cuda functions that are being unconditionally invoked
+        # in the multiprocessing data loader
+        torch.cuda.current_device = lambda: None
+        torch.cuda.set_device = lambda x: None
+
+    if args.dl_worker_type == "MP":
+        data_loader_type = torch.utils.data.DataLoader
+    elif args.dl_worker_type == "HABANA":
+        data_loader_type = habana_dataloader.HabanaDataLoader
+
+    pin_memory_device = None
+    pin_memory = False
+    if args.device == 'cuda' or args.device == 'hpu':
+        pin_memory_device = args.device
+        pin_memory = True
+
+    print("Creating model")
+    # Import only resnext101_32x4d from a local copy since torchvision
+    # package doesn't support resnext101_32x4d variant
+    if 'resnext101_32x4d' in args.model:
+        model = resnet_models.__dict__[args.model](pretrained=args.pretrained)
+    else:
+        model = torchvision.models.__dict__[
+            args.model](pretrained=args.pretrained)
+    model.to(device)
+    if args.device=='hpu' and args.run_lazy_mode and args.hpu_graphs:
+        import habana_frameworks.torch.hpu.graphs as htgraphs
+        htgraphs.ModuleCacher()(model, have_grad_accumulation=True)
+    if args.channels_last:
+        if(device == torch.device('cuda')):
+            print('Converting model to channels_last format on CUDA')
+            model.to(memory_format=torch.channels_last)
+        elif(args.device == 'hpu'):
+            print('Converting model params to channels_last format on Habana')
+            # TODO:
+            # model.to(device).to(memory_format=torch.channels_last)
+            # The above model conversion doesn't change the model params
+            # to channels_last for many components - e.g. convolution.
+            # So we are forced to rearrange such tensors ourselves.
+
+    if args.distributed and args.sync_bn:
+        model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(model)
+
+    criterion = nn.CrossEntropyLoss(label_smoothing=args.label_smoothing, reduction='sum')
+
+    print("************* Running FusedResourceApplyMomentum optimizer ************")
+    from habana_frameworks.torch.hpex.optimizers import FusedResourceApplyMomentum
+    optimizer = FusedResourceApplyMomentum(
+        model.parameters(), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay)
+
+    mlperf_mlloger.event(key=mlperf_mllog.constants.LARS_OPT_WEIGHT_DECAY, value=args.weight_decay)
+    mlperf_mlloger.event(key='lars_opt_momentum', value=args.momentum)
+
+    skip_list = ['batch_normalization', 'bias', 'bn', 'downsample.1']
+    skip_mask = []
+    for n_param, param in zip(model.named_parameters(), model.parameters()):
+        assert n_param[1].shape == param.shape
+        skip_mask.append(not any(v in n_param[0] for v in skip_list))
+
+    mlperf_variable_map = get_mlperf_variable_map()
+    for model_weight, param in model.named_parameters():
+        mlperf_mlloger.event(key=mlperf_mllog.constants.WEIGHTS_INITIALIZATION, metadata={'tensor': mlperf_variable_map[model_weight]})
+
+    print("************* Running FusedLARS optimizer ************")
+    from habana_frameworks.torch.hpex.optimizers import FusedLars
+    optimizer = FusedLars(optimizer, skip_mask, eps=0.0)
+
+    mlperf_mlloger.event(key=mlperf_mllog.constants.OPT_NAME, value='lars')
+    mlperf_mlloger.event(key=mlperf_mllog.constants.LARS_EPSILON, value=0.0)
+
+    if args.apex:
+        model, optimizer = amp.initialize(model, optimizer,
+                                          opt_level=args.apex_opt_level
+                                          )
+    NUM_IMAGES = {
+        'train': 1281167,
+        'validation': 50000,
+    }
+    steps_per_epoch = ceil(NUM_IMAGES['train'] / utils.get_world_size() / args.batch_size)
+    steps_per_eval = ceil(NUM_IMAGES['validation'] / utils.get_world_size() / args.batch_size)
+    train_print_freq = min(args.print_freq, steps_per_epoch - 1)
+    eval_print_freq = min(args.print_freq, steps_per_eval - 1)
+
+    print("************* PolynomialDecayWithWarmup  ************")
+    from model.optimizer import PolynomialDecayWithWarmup
+    train_steps = steps_per_epoch * args.epochs
+    lr_scheduler = PolynomialDecayWithWarmup(optimizer,
+                                             batch_size=args.batch_size,
+                                             steps_per_epoch=steps_per_epoch,
+                                             train_steps=train_steps,
+                                             initial_learning_rate=args.base_learning_rate,
+                                             warmup_epochs=args.warmup_epochs,
+                                             end_learning_rate=args.end_learning_rate,
+                                             power=2.0,
+                                             lars_decay_epochs=args.lars_decay_epochs,
+                                             mlperf_mllog=mlperf_mllog,
+                                             mlperf_mlloger=mlperf_mlloger,
+                                             opt_name='lars')
+
+    model_for_eval = model
+
+    # TBD: pass the right module for ddp
+    model_without_ddp = model
+
+    if args.distributed:
+        if args.device == 'hpu':
+            # To improve resnext101 dist performance,
+            # decrease number of all_reduce calls to 1 by increasing bucket size to 200
+            bucket_size_mb = 200
+            is_grad_view = True
+            model = torch.nn.parallel.DistributedDataParallel(model,
+                                                              bucket_cap_mb=bucket_size_mb,
+                                                              broadcast_buffers=False,
+                                                              gradient_as_bucket_view=is_grad_view)
+        else:
+            model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.gpu])
+        model_without_ddp = model.module
+
+    model_for_train = model
+
+    if args.resume:
+        checkpoint = torch.load(args.resume, map_location='cpu')
+        model_without_ddp.load_state_dict(checkpoint['model'])
+        optimizer.load_state_dict(checkpoint['optimizer'])
+        if lr_scheduler is not None:
+            lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])
+
+        args.start_epoch = checkpoint['epoch'] + 1
+
+    if args.test_only:
+        evaluate(model_for_eval, criterion, data_loader_test, device=device,
+                 print_freq=eval_print_freq)
+        return
+
+    if (args.enable_warmup):
+        warmup_start_time = time.time()
+        print("Start warmup")
+        warmup(model_for_train, model_for_eval, device, criterion, optimizer, args, data_loader_type, pin_memory_device, pin_memory)
+        warmup_total_time = time.time() - warmup_start_time
+        warmup_total_time_str = str(datetime.timedelta(seconds=int(warmup_total_time)))
+        print(f'Warmup time {warmup_total_time_str}')
+
+    mlperf_mlloger.event(key=mlperf_mllog.constants.GLOBAL_BATCH_SIZE, value=args.batch_size*utils.get_world_size())
+    mlperf_mlloger.event(key=mlperf_mllog.constants.TRAIN_SAMPLES, value=NUM_IMAGES['train'])
+    mlperf_mlloger.event(key=mlperf_mllog.constants.EVAL_SAMPLES, value=NUM_IMAGES['validation'])
+    group_batch_norm = 1
+    mlperf_mlloger.event(key=mlperf_mllog.constants.MODEL_BN_SPAN, value= args.batch_size * group_batch_norm)
+    mlperf_mlloger.event(key=mlperf_mllog.constants.GRADIENT_ACCUMULATION_STEPS, value=args.num_acc_steps)
+
+    next_eval_epoch = args.eval_offset_epochs - 1 + args.start_epoch
+    if next_eval_epoch < 0:
+        next_eval_epoch += args.epochs_between_evals
+
+    train_dir = os.path.join(args.data_path, 'train')
+    val_dir = os.path.join(args.data_path, 'val')
+
+    if utils.get_rank() == 0:
+        try:
+            shutil.rmtree(synth_data_dir)
+        except:
+            pass
+
+    dataset_manifest = prepare_dataset_manifest(args)
+
+    print("Start training")
+    top1_acc = 0
+    start_time = time.time()
+    mlperf_mlloger.end(key=mlperf_mllog.constants.INIT_STOP)
+
+    if utils.get_world_size() > 1:
+        utils.barrier()
+
+    mlperf_mlloger.start(key=mlperf_mllog.constants.RUN_START)
+
+    dataset, dataset_test, train_sampler, test_sampler = load_data(train_dir, val_dir, args, dataset_manifest)
+    data_loader = data_loader_type(
+        dataset, batch_size=args.batch_size, sampler=train_sampler,
+        num_workers=args.workers, pin_memory=pin_memory, pin_memory_device=pin_memory_device)
+
+    data_loader_test = data_loader_type(
+        dataset_test, batch_size=args.batch_size, sampler=test_sampler,
+        num_workers=args.workers, pin_memory=pin_memory, pin_memory_device=pin_memory_device)
+
+    if args.use_torch_compile:
+        model_for_train = torch.compile(model_for_train, backend="aot_hpu_training_backend")
+        model_for_eval = torch.compile(model_for_eval, backend="aot_hpu_training_backend")
+
+    mlperf_mlloger.start(
+        key=mlperf_mllog.constants.BLOCK_START,
+        value=None,
+        metadata={
+            'first_epoch_num': 1,
+            'epoch_count':
+                (args.eval_offset_epochs if args.eval_offset_epochs > 0
+                 else args.epochs_between_evals)
+        })
+    for epoch in range(args.start_epoch, args.epochs):
+        # Setting epoch is done by Habana dataloader internally
+        if args.distributed and args.dl_worker_type != "HABANA":
+            train_sampler.set_epoch(epoch)
+
+        train_one_epoch(lr_scheduler, model_for_train, criterion, optimizer, data_loader,
+                        device, epoch, print_freq=train_print_freq, args=args, apex=args.apex)
+
+        if epoch == next_eval_epoch:
+            mlperf_mlloger.start(
+                key=mlperf_mllog.constants.EVAL_START, value=None, metadata={'epoch_num': epoch + 1})
+            top1_acc = evaluate(model_for_eval, criterion, data_loader_test, device=device,
+                 print_freq=eval_print_freq) / 100.
+            mlperf_mlloger.end(
+                key=mlperf_mllog.constants.EVAL_STOP, value=None, metadata={'epoch_num': epoch + 1})
+            mlperf_mlloger.event(
+                key=mlperf_mllog.constants.EVAL_ACCURACY, value=top1_acc, metadata={'epoch_num': epoch + 1})
+
+            first_epoch_num = max(epoch - args.epochs_between_evals + 1, 0)
+            epoch_count = args.epochs_between_evals
+            if first_epoch_num == 0:
+                epoch_count = args.eval_offset_epochs
+                if epoch_count == 0:
+                    epoch_count = args.epochs_between_evals
+            mlperf_mlloger.end(
+                key=mlperf_mllog.constants.BLOCK_STOP,
+                value=None,
+                metadata={
+                    'first_epoch_num': first_epoch_num + 1,
+                    'epoch_count': epoch_count
+                })
+
+            if top1_acc >= args.target_accuracy:
+                break
+
+            next_eval_epoch += args.epochs_between_evals
+
+            if next_eval_epoch < args.epochs:
+                mlperf_mlloger.start(
+                    key=mlperf_mllog.constants.BLOCK_START,
+                    value=None,
+                    metadata={
+                        'first_epoch_num': epoch + 2,
+                        'epoch_count': args.epochs_between_evals
+                    })
+
+
+        if (args.output_dir and args.save_checkpoint):
+            if args.device == 'hpu':
+                checkpoint = {
+                    'model': model_without_ddp.state_dict(),
+                    'optimizer': optimizer.state_dict(),
+                    'lr_scheduler': None if lr_scheduler is None else lr_scheduler.state_dict(),
+                    'epoch': epoch,
+                    'args': args}
+
+                utils.save_on_master(
+                    checkpoint,
+                    os.path.join(args.output_dir, 'model_{}.pth'.format(epoch)))
+                utils.save_on_master(
+                    checkpoint,
+                    os.path.join(args.output_dir, 'checkpoint.pth'))
+
+            else:
+                checkpoint = {
+                    'model': model_without_ddp.state_dict(),
+                    'optimizer': optimizer.state_dict(),
+                    'lr_scheduler': None if lr_scheduler is None else lr_scheduler.state_dict(),
+                    'epoch': epoch,
+                    'args': args}
+                utils.save_on_master(
+                    checkpoint,
+                    os.path.join(args.output_dir, 'model_{}.pth'.format(epoch)))
+                utils.save_on_master(
+                    checkpoint,
+                    os.path.join(args.output_dir, 'checkpoint.pth'))
+
+    if top1_acc >= args.target_accuracy:
+        mlperf_mlloger.end(key=mlperf_mllog.constants.RUN_STOP, value=None, metadata={'status': 'success'})
+    else:
+        mlperf_mlloger.end(key=mlperf_mllog.constants.RUN_STOP, value=None, metadata={'status': 'fail'})
+
+    total_time = time.time() - start_time
+    total_time_str = str(datetime.timedelta(seconds=int(total_time)))
+    print('Training time {}'.format(total_time_str))
+
+
+def set_env_params():
+    os.environ["MAX_WAIT_ATTEMPTS"] = "50"
+    os.environ['HCL_CPU_AFFINITY'] = '1'
+
+
+def prepare_dataset_manifest(args):
+    import glob
+    import pathlib
+
+    if args.data_path is not None:
+        # get files list
+        dataset_dir = os.path.join(args.data_path, 'train')
+
+        print(f"dataset dir: {dataset_dir}")
+        manifest_data = {}
+        manifest_data["file_list"] = sorted(
+            glob.glob(dataset_dir + "/*/*.{}".format("JPEG")))
+
+        # get class list
+        data_dir = pathlib.Path(dataset_dir)
+        manifest_data["class_list"] = sorted(
+            [item.name for item in data_dir.glob('*') if item.is_dir() == True])
+
+        file_sizes = {}
+
+        for filename in manifest_data["file_list"]:
+            file_sizes[filename] = os.stat(filename).st_size
+
+        manifest_data['file_sizes'] = file_sizes
+
+        return manifest_data
+
+
+def parse_args():
+    import argparse
+    parser = argparse.ArgumentParser(
+        description='PyTorch Classification Training')
+
+    parser.add_argument('--data-path', default='/root/software/lfs/data/data/pytorch/imagenet/ILSVRC2012/',
+                        help='dataset')
+    parser.add_argument('--dl-time-exclude', default='True', type=lambda x: x.lower() == 'true',
+                        help='Set to False to include data load time')
+    parser.add_argument('--model', default='resnet18',
+                        help='select Resnet models from resnet18, resnet34, resnet50, resnet101, resnet152,'
+                             'resnext50_32x4d, resnext101_32x4d, resnext101_32x8d, wide_resnet50_2, wide_resnet101_2')
+    parser.add_argument('--device', default='hpu', help='device')
+    parser.add_argument('-b', '--batch-size', default=128, type=int)
+    parser.add_argument('--epochs', default=90, type=int, metavar='N',
+                        help='number of total epochs to run')
+    parser.add_argument('-ebe', '--epochs_between_evals', default=4, type=int, metavar='N',
+                        help='number of epochs to be completed before evaluation (default: 4)')
+    parser.add_argument('-eoe', '--eval_offset_epochs', default=0, type=int, metavar='N',
+                        help='offsets the epoch on which the evaluation starts (default: 0)')
+    parser.add_argument('--dl-worker-type', default='HABANA', type=lambda x: x.upper(),
+                        choices=["MP", "HABANA"], help='select multiprocessing or habana accelerated')
+    parser.add_argument('-j', '--workers', default=10, type=int, metavar='N',
+                        help='number of data loading workers (default: 10)')
+    parser.add_argument('--process-per-node', default=8, type=int, metavar='N',
+                        help='Number of process per node')
+    parser.add_argument('--hls_type', default='HLS2', help='Node type')
+    parser.add_argument('--lars_decay_epochs', default='36', type=int, help='number of decay epochs')
+    parser.add_argument('--warmup_epochs', default='3', type=int, help='number of warmup epochs')
+    parser.add_argument('--base_learning_rate', default='9', type=float, help='base learning rate')
+    parser.add_argument('--end_learning_rate', default='0.0001', type=float, help='end learning rate')
+    parser.add_argument('--lr', default=0.1, type=float, help='initial learning rate')
+    parser.add_argument('--momentum', default=0.9, type=float, metavar='M',
+                        help='momentum')
+    parser.add_argument('--wd', '--weight-decay', default=5e-5, type=float,
+                        metavar='W', help='weight decay (default: 5e-5)',
+                        dest='weight_decay')
+    parser.add_argument('--lr-step-size', default=30, type=int,
+                        help='decrease lr every step-size epochs')
+    parser.add_argument('--custom-lr-values', default=None, metavar='N', type=float, nargs='+',
+                        help='custom lr values list')
+    parser.add_argument('--custom-lr-milestones', default=None, metavar='N', type=int, nargs='+',
+                        help='custom lr milestones list')
+    parser.add_argument('--lr-gamma', default=0.1, type=float,
+                        help='decrease lr by a factor of lr-gamma')
+    parser.add_argument('--label-smoothing', default=0.1, type=float,
+                        help='Apply label smoothing to the loss. This applies to'
+                             'CrossEntropyLoss, when label_smoothing is greater than 0.')
+    parser.add_argument('--print-freq', default=1, type=int, help='print frequency')
+    parser.add_argument('--output-dir', default='.', help='path where to save')
+    parser.add_argument('--log-dir', default='', help='destination path for mllogs')
+    parser.add_argument('--profile-steps', default=None,
+                        help='Profile steps range separated by comma (e.g. `--profile_steps 100,105`)')
+
+    parser.add_argument('--channels-last', default='False', type=lambda x: x.lower() == 'true',
+                        help='Whether input is in channels last format.'
+                        'Any value other than True(case insensitive) disables channels-last')
+    parser.add_argument('--resume', default='', help='resume from checkpoint')
+    parser.add_argument('--start-epoch', default=0, type=int, metavar='N',
+                        help='start epoch')
+    parser.add_argument('--num_acc_steps', type=int, default=1, help='Number of gradient accumulation steps')
+    parser.add_argument('--num_gpus', type=int, default=0, help='Number of used gpus to run the model')
+    parser.add_argument('--target_accuracy', default=0.759, type=float, help='Quality target of training')
+    parser.add_argument(
+        "--cache-dataset",
+        dest="cache_dataset",
+        help="Cache the datasets for quicker initialization. It also serializes the transforms",
+        action="store_true",
+    )
+    parser.add_argument(
+        "--use_torch_compile",
+        dest="use_torch_compile",
+        help="Use torch.compile feature to run the model",
+        action="store_true",
+    )
+    parser.add_argument(
+        "--sync-bn",
+        dest="sync_bn",
+        help="Use sync batch norm",
+        action="store_true",
+    )
+    parser.add_argument(
+        "--test-only",
+        dest="test_only",
+        help="Only test the model",
+        action="store_true",
+    )
+    parser.add_argument(
+        "--pretrained",
+        dest="pretrained",
+        help="Use pre-trained models from the modelzoo",
+        action="store_true",
+    )
+    parser.add_argument(
+        "--hpu_graphs",
+        dest="hpu_graphs",
+        help="Use HPU graphs feature to run the model by default",
+        default='True', type=lambda x: x.lower() == 'true',
+    )
+    parser.add_argument('--enable-warmup', default='True', type=lambda x: x.lower() == 'true',
+                    help='Whether the warmup is enabled')
+
+    # Mixed precision training parameters
+    parser.add_argument('--apex', action='store_true',
+                        help='Use apex for mixed precision training')
+    parser.add_argument('--apex-opt-level', default='O1', type=str,
+                        help='For apex mixed precision training'
+                             'O0 for FP32 training, O1 for mixed precision training.'
+                             'For further detail, see https://github.com/NVIDIA/apex/tree/master/examples/imagenet'
+                        )
+
+    # distributed training parameters
+    parser.add_argument('--world-size', default=1, type=int,
+                        help='number of distributed processes')
+    parser.add_argument('--dist-url', default='env://',
+                        help='url used to set up distributed training')
+    parser.add_argument('--num-train-steps', type=int, default=sys.maxsize, metavar='T',
+                        help='number of steps a.k.a iterations to run in training phase')
+    parser.add_argument('--num-eval-steps', type=int, default=sys.maxsize, metavar='E',
+                        help='number of steps a.k.a iterations to run in evaluation phase')
+    parser.add_argument('--save-checkpoint', action="store_true",
+                        help='Whether or not to save model/checkpont; True: to save, False to avoid saving')
+    parser.add_argument('--run-lazy-mode', default='True', type=lambda x: x.lower() == 'true',
+                        help='run model in lazy execution mode(enabled by default).'
+                        'Any value other than True(case insensitive) disables lazy mode')
+    parser.add_argument('--use_autocast', action='store_true', help='enable autocast')
+
+    args = parser.parse_args()
+
+    return args
+
+
+if __name__ == "__main__":
+    set_env_params()
+    args = parse_args()
+    main(args)

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

@@ -0,0 +1,273 @@
+# Copyright (c) 2022, Habana Labs Ltd.  All rights reserved.
+
+
+from __future__ import print_function
+from collections import defaultdict, deque
+import datetime
+import time
+import torch
+import torch.distributed as dist
+import errno
+import os
+mpi_comm = None
+
+
+class SmoothedValue(object):
+    """Track a series of values and provide access to smoothed values over a
+    window or the global series average.
+    """
+
+    def __init__(self, window_size=20, fmt=None):
+        if fmt is None:
+            fmt = "{median:.4f} ({global_avg:.4f})"
+        self.deque = deque(maxlen=window_size)
+        self.total = 0.0
+        self.count = 0
+        self.fmt = fmt
+
+    def update(self, value, n=1):
+        self.deque.append(value)
+        self.count += n
+        self.total += value * n
+
+    def synchronize_between_processes(self, device):
+        """
+        Warning: does not synchronize the deque!
+        """
+        if not is_dist_avail_and_initialized():
+            return
+        if device.type == 'hpu':
+            t = torch.tensor([self.count, self.total], dtype=torch.float32).to('hpu')
+        else:
+            t = torch.tensor([self.count, self.total], dtype=torch.float64, device='cuda')
+            dist.barrier()
+
+        dist.all_reduce(t)
+        t = t.tolist()
+        self.count = int(t[0])
+        self.total = t[1]
+
+    @property
+    def median(self):
+        d = torch.tensor(list(self.deque))
+        return d.median().item()
+
+    @property
+    def avg(self):
+        d = torch.tensor(list(self.deque), dtype=torch.float32)
+        return d.mean().item()
+
+    @property
+    def global_avg(self):
+        return self.total / self.count
+
+    @property
+    def max(self):
+        return max(self.deque)
+
+    @property
+    def value(self):
+        return self.deque[-1]
+
+    def __str__(self):
+        return self.fmt.format(
+            median=self.median,
+            avg=self.avg,
+            global_avg=self.global_avg,
+            max=self.max,
+            value=self.value)
+
+
+class MetricLogger(object):
+    def __init__(self, delimiter="\t", device=torch.device('cuda')):
+        self.meters = defaultdict(SmoothedValue)
+        self.delimiter = delimiter
+        self.device = device
+
+    def update(self, **kwargs):
+        for k, v in kwargs.items():
+            if isinstance(v, torch.Tensor):
+                v = v.item()
+            assert isinstance(v, (float, int))
+            self.meters[k].update(v)
+
+    def __getattr__(self, attr):
+        if attr in self.meters:
+            return self.meters[attr]
+        if attr in self.__dict__:
+            return self.__dict__[attr]
+        raise AttributeError("'{}' object has no attribute '{}'".format(
+            type(self).__name__, attr))
+
+    def __str__(self):
+        loss_str = []
+        for name, meter in self.meters.items():
+            loss_str.append(
+                "{}: {}".format(name, str(meter))
+            )
+        return self.delimiter.join(loss_str)
+
+    def synchronize_between_processes(self):
+        for meter in self.meters.values():
+            meter.synchronize_between_processes(self.device)
+
+    def add_meter(self, name, meter):
+        self.meters[name] = meter
+
+    def log_every(self, iterable, print_freq, header=None):
+        i = 0
+        if not header:
+            header = ''
+        start_time = time.time()
+        end = time.time()
+        iter_time = SmoothedValue(fmt='{avg:.4f}')
+        data_time = SmoothedValue(fmt='{avg:.4f}')
+        space_fmt = ':' + str(len(str(len(iterable)))) + 'd'
+        if torch.cuda.is_available():
+            log_msg = self.delimiter.join([
+                header,
+                '[{0' + space_fmt + '}/{1}]',
+                'eta: {eta}',
+                '{meters}',
+                'time: {time}',
+                'data: {data}',
+                'max mem: {memory:.0f}'
+            ])
+        else:
+            log_msg = self.delimiter.join([
+                header,
+                '[{0' + space_fmt + '}/{1}]',
+                'eta: {eta}',
+                '{meters}',
+                'time: {time}',
+                'data: {data}'
+            ])
+        MB = 1024.0 * 1024.0
+        for obj in iterable:
+            data_time.update(time.time() - end)
+            yield obj
+            iter_time.update(time.time() - end)
+            if i % print_freq == 0:
+                eta_seconds = iter_time.global_avg * (len(iterable) - i)
+                eta_string = str(datetime.timedelta(seconds=int(eta_seconds)))
+                if torch.cuda.is_available():
+                    print(log_msg.format(
+                        i, len(iterable), eta=eta_string,
+                        meters=str(self),
+                        time=str(iter_time), data=str(data_time),
+                        memory=torch.cuda.max_memory_allocated() / MB))
+                else:
+                    print(log_msg.format(
+                        i, len(iterable), eta=eta_string,
+                        meters=str(self),
+                        time=str(iter_time), data=str(data_time)))
+            i += 1
+            end = time.time()
+        total_time = time.time() - start_time
+        total_time_str = str(datetime.timedelta(seconds=int(total_time)))
+        print('{} Total time: {}'.format(header, total_time_str))
+
+
+# Modified version of accuracy. target and pred tensors are pytorch Long
+# which is not supported by habana kernels yet. So fall back to CPU for
+# ops involving these(and remain on CPU since this is the last oprton of
+# iteration and we need the accuracy values to be printed out on host)
+def accuracy(output, target, topk=(1,)):
+    """Computes the accuracy over the k top predictions for the specified values of k"""
+    with torch.no_grad():
+        maxk = max(topk)
+        batch_size = target.size(0)
+
+        _, pred = output.topk(maxk, 1, True, True)
+
+        pred = pred.t()
+        pred_cpu = torch.tensor(pred, device='cpu')
+        target_cpu = torch.tensor(target, device='cpu')
+
+        correct = pred_cpu.eq(target_cpu[None])
+
+        res = []
+        for k in topk:
+            correct_k = correct[:k].flatten().sum(dtype=torch.float32)
+            res.append(correct_k * (100.0 / batch_size))
+        return res
+
+
+def mkdir(path):
+    try:
+        os.makedirs(path)
+    except OSError as e:
+        if e.errno != errno.EEXIST:
+            raise
+
+
+def setup_for_distributed(is_master):
+    """
+    This function disables printing when not in master process
+    """
+    import builtins as __builtin__
+    builtin_print = __builtin__.print
+
+    def print(*args, **kwargs):
+        force = kwargs.pop('force', False)
+        if is_master or force:
+            builtin_print(*args, **kwargs)
+
+    __builtin__.print = print
+
+
+def is_dist_avail_and_initialized():
+    if not dist.is_available():
+        return False
+    if not dist.is_initialized():
+        return False
+    return True
+
+
+def get_world_size():
+    if not is_dist_avail_and_initialized():
+        return 1
+    return dist.get_world_size()
+
+
+def get_rank():
+    if not is_dist_avail_and_initialized():
+        return 0
+    return dist.get_rank()
+
+
+def is_main_process():
+    return get_rank() == 0
+
+
+def save_on_master(*args, **kwargs):
+    if is_main_process():
+        torch.save(*args, **kwargs)
+
+
+def barrier():
+    dist.barrier()
+
+
+def init_distributed_mode(args):
+    from habana_frameworks.torch.distributed.hccl import initialize_distributed_hpu
+    args.world_size, args.rank, args.local_rank = initialize_distributed_hpu()
+    if args.world_size == 1:
+        args.distributed = False
+        return
+
+    args.distributed = True
+    print('| distributed init (rank {}): {}'.format(
+        args.rank, args.dist_url), flush=True)
+
+    if args.device == 'hpu':
+        args.dist_backend = 'hccl'
+        dist._DEFAULT_FIRST_BUCKET_BYTES = 200 * 1024 * 1024  # 200MB
+        dist.init_process_group(args.dist_backend, rank=args.rank, world_size=args.world_size)
+    else:
+        torch.cuda.set_device(args.gpu)
+        args.dist_backend = 'nccl'
+        torch.distributed.init_process_group(backend=args.dist_backend, init_method=args.dist_url,
+                                             world_size=args.world_size, rank=args.rank)
+
+    setup_for_distributed(args.rank == 0)

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

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+# general param
+export NUM_WORKERS_PER_HLS=8
+export EVAL_OFFSET_EPOCHS=3
+export EPOCHS_BETWEEN_EVALS=4
+export DISPLAY_STEPS=1000
+
+# hp param
+export NUM_WORKERS=8
+export BATCH_SIZE=256
+export TRAIN_EPOCHS=35
+export LARS_DECAY_EPOCHS=36
+export WARMUP_EPOCHS=3
+export BASE_LEARNING_RATE=9
+export END_LEARNING_RATE=0.0001
+export WEIGHT_DECAY=0.00005
+export LR_MOMENTUM=0.9
+export LABEL_SMOOTH=0.1
+export STOP_THRESHOLD=0.759

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

@@ -0,0 +1,203 @@
+#!/bin/bash
+
+function print_synopsis()
+{
+    cat << EOF
+NAME
+        `basename $0`
+
+SYNOPSIS
+        `basename $0` [-c <config>] [-ld <log-dir>] [-wd <work-dir>] [-dd <data-dir>] [-h]
+
+DESCRIPTION
+        Runs 8-gaudi local MLPerf Resnet training on PyTorch.
+
+        -c <config-file>, --config <config-file>
+            configuration file containing series of "export VAR_NAME=value" commands
+            overrides default settings for Resnet training
+
+        -ld <log-dir>, --log-dir <log-dir>
+            specify the loggin directory, used to store mllogs and outputs from all mpi processes
+
+        -wd <work-dir>, --work-dir <work-dir>
+            specify the work directory, used to store temporary files during the training
+
+        -dd <data-dir>
+            specify the data directory, containing the ImageNet dataset
+
+        -ut <bool>, --use-torch-compile <bool>
+            turn on the torch compile, default is false
+
+        -h, --help
+            print this help message
+
+EXAMPLES
+       `basename $0` -wd /data/imagenet
+            MLPerf Resnet training on dataset stored in /data/imagenet
+
+EOF
+}
+
+function parse_config()
+{
+    while [ -n "$1" ]; do
+        case "$1" in
+            -c | --config )
+                CONFIG_FILE=$2
+                if [[ -f ${CONFIG_FILE} ]]; then
+	                source $CONFIG_FILE
+                    return
+                else
+                    echo "Could not find ${CONFIG_FILE}"
+                    exit 1
+                fi
+                ;;
+            * )
+                shift
+                ;;
+        esac
+    done
+}
+
+function parse_args()
+{
+    while [ -n "$1" ]; do
+        case "$1" in
+            -c | --config )
+                shift 2
+                ;;
+            -ld | --log-dir )
+                LOG_DIR=$2
+                shift 2
+                ;;
+            -wd | --work-dir )
+                WORK_DIR=$2
+                shift 2
+                ;;
+            -dd | --data-dir )
+                DATA_DIR=$2
+                shift 2
+                ;;
+            -ut | --use-torch-compile )
+                USE_TORCH_COMPILE=$2
+                shift 2
+                ;;
+            -h | --help )
+                print_synopsis
+                exit 0
+                ;;
+            * )
+                echo "error: invalid parameter: $1"
+                print_synopsis
+                exit 1
+                ;;
+        esac
+    done
+}
+
+# Default setting for Pytorch Resnet trainig
+
+NUM_WORKERS_PER_HLS=8
+EVAL_OFFSET_EPOCHS=3
+EPOCHS_BETWEEN_EVALS=4
+DISPLAY_STEPS=1000
+
+NUM_WORKERS=8
+BATCH_SIZE=256
+TRAIN_EPOCHS=35
+LARS_DECAY_EPOCHS=36
+WARMUP_EPOCHS=3
+BASE_LEARNING_RATE=9
+END_LEARNING_RATE=0.0001
+WEIGHT_DECAY=0.00005
+LR_MOMENTUM=0.9
+LABEL_SMOOTH=0.1
+STOP_THRESHOLD=0.759
+USE_TORCH_COMPILE=false
+
+DATA_DIR=/mnt/weka/data/pytorch/imagenet/ILSVRC2012/
+
+WORK_DIR=/tmp/resnet50
+LOG_DIR=/tmp/resnet_log
+SCRIPT_DIR=$(dirname "${BASH_SOURCE[0]}")
+
+# Default MPI settings
+MPI_HOSTS=localhost:8
+MPI_OUTPUT=/tmp/resnet_log
+MPI_PATH=/opt/amazon/openmpi
+SSH_PORT=3022
+
+# MASTER_ADDR and MASTER_PORT are consumed by PyTorch c10d to establish a distributed group
+export MASTER_ADDR=${MASTER_ADDR:-127.0.0.1}
+export MASTER_PORT=${MASTER_PORT:-12345}
+
+# apply optional config, overwriting default settings
+parse_config "$@"
+
+# optional command line arguments overwrite both default and config settings
+parse_args "$@"
+
+# Use torch compile
+if [ "$USE_TORCH_COMPILE" == "true" ]; then
+    echo "torch.compile enabled"
+    TOCH_COMPILE_FLAGS="--use_torch_compile --run-lazy-mode false"
+else
+    TORCH_COMPILE_FLAGS=""
+fi
+
+# Clear caches
+PROC_FS=${PROC_FS:-"/proc"}
+sync && echo 3 > $PROC_FS/sys/vm/drop_caches
+
+# determine the number of available cores for each process
+MPI_MAP_BY_PE=`lscpu | grep "^CPU(s):"| awk -v NUM=${NUM_WORKERS_PER_HLS} '{print int($2/NUM/2)}'`
+
+# prepare directories
+rm -rf $LOG_DIR
+mkdir -p $WORK_DIR
+mkdir -p $LOG_DIR
+
+# run Pytorch Resnet training
+mpirun \
+--allow-run-as-root \
+--np $NUM_WORKERS \
+--bind-to core \
+--rank-by core \
+--map-by socket:PE=$MPI_MAP_BY_PE \
+-H $MPI_HOSTS \
+--report-bindings \
+--tag-output \
+--merge-stderr-to-stdout \
+--output-filename $LOG_DIR \
+--prefix $MPI_PATH \
+-x PT_HPU_AUTOCAST_LOWER_PRECISION_OPS_LIST=$SCRIPT_DIR/PyTorch/ops_bf16_Resnet.txt \
+-x PT_HPU_AUTOCAST_FP32_OPS_LIST=$SCRIPT_DIR/PyTorch/ops_fp32_Resnet.txt \
+python3 $SCRIPT_DIR/PyTorch/train.py \
+--model resnet50 \
+--device hpu \
+--print-freq $DISPLAY_STEPS \
+--channels-last False \
+--dl-time-exclude False \
+--output-dir $WORK_DIR \
+--log-dir $LOG_DIR \
+--data-path $DATA_DIR \
+--eval_offset_epochs $EVAL_OFFSET_EPOCHS \
+--epochs_between_evals $EPOCHS_BETWEEN_EVALS \
+--workers $NUM_WORKERS_PER_HLS \
+--batch-size $BATCH_SIZE \
+--epochs $TRAIN_EPOCHS \
+--lars_decay_epochs $LARS_DECAY_EPOCHS \
+--warmup_epochs $WARMUP_EPOCHS \
+--base_learning_rate $BASE_LEARNING_RATE \
+--end_learning_rate $END_LEARNING_RATE \
+--weight-decay $WEIGHT_DECAY \
+--momentum $LR_MOMENTUM \
+--label-smoothing $LABEL_SMOOTH \
+--target_accuracy $STOP_THRESHOLD \
+--use_autocast \
+ $TOCH_COMPILE_FLAGS \
+--dl-worker-type HABANA
+
+# finalize LOG_DIR folder
+chmod -R 777 ${LOG_DIR}
+exit 0

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/implementations/TensorFlow/computer_vision/Resnets/resnet_keras/mlp_log.py

@@ -0,0 +1,57 @@
+# Copyright 2018 MLBenchmark Group. 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.
+# ==============================================================================
+"""Convenience function for logging compliance tags to stdout.
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+
+import inspect
+import json
+import logging
+import os
+import re
+import sys
+import time
+
+try:
+    import horovod.tensorflow as hvd
+except ImportError:
+    hvd = None
+
+def get_mllog_mlloger(output_dir=None):
+    from mlperf_logging import mllog
+
+    if hvd is not None and hvd.is_initialized():
+        str_hvd_rank = str(hvd.rank())
+    else:
+        str_hvd_rank = "0"
+    mllogger = mllog.get_mllogger()
+    mllogger.propagate = False
+    mllog.propagate=False
+    if output_dir is None: output_dir='./log'
+    filenames = os.path.normpath(output_dir) + "/result_rank_" + str_hvd_rank + ".txt"
+    mllog.config(filename=filenames)
+    workername = "worker" + str_hvd_rank
+    mllog.config(
+            default_namespace = workername,
+            default_stack_offset = 1,
+            default_clear_line = False,
+            root_dir = os.path.normpath(
+           os.path.join(os.path.dirname(os.path.realpath(__file__)), "..", "..")))
+
+    return mllogger, mllog

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/implementations/TensorFlow/computer_vision/Resnets/resnet_keras/requirements.txt

@@ -0,0 +1,7 @@
+absl_py==1.0.0
+cloudpickle==1.6.0
+psutil==5.8.0
+PyYAML==6.0.0
+requests==2.25.1
+tensorflow_model_optimization==0.7.2
+git+https://github.com/mlperf/[email protected]

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/implementations/TensorFlow/computer_vision/Resnets/resnet_keras/resnet_model.py

@@ -0,0 +1,323 @@
+# Copyright 2021 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.
+
+"""ResNet50 model for Keras.
+Adapted from tf.keras.applications.resnet50.ResNet50().
+This is ResNet model version 1.5.
+Related papers/blogs:
+- https://arxiv.org/abs/1512.03385
+- https://arxiv.org/pdf/1603.05027v2.pdf
+- http://torch.ch/blog/2016/02/04/resnets.html
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from absl import flags
+import tensorflow as tf
+from TensorFlow.computer_vision.common import imagenet_preprocessing
+
+FLAGS = flags.FLAGS
+flags.DEFINE_float(
+    'weight_decay',
+    default=1e-4,
+    help=('Weight decay coefficiant for l2 regularization.'))
+
+layers = tf.keras.layers
+
+
+def _gen_l2_regularizer(use_l2_regularizer=True):
+  return tf.keras.regularizers.L2(
+      FLAGS.weight_decay) if use_l2_regularizer else None
+
+
+def identity_block(input_tensor,
+                   kernel_size,
+                   filters,
+                   stage,
+                   block,
+                   use_l2_regularizer=True,
+                   batch_norm_decay=0.9,
+                   batch_norm_epsilon=1e-5):
+  """The identity block is the block that has no conv layer at shortcut.
+  Args:
+    input_tensor: input tensor
+    kernel_size: default 3, the kernel size of middle conv layer at main path
+    filters: list of integers, the filters of 3 conv layer at main path
+    stage: integer, current stage label, used for generating layer names
+    block: 'a','b'..., current block label, used for generating layer names
+    use_l2_regularizer: whether to use L2 regularizer on Conv layer.
+    batch_norm_decay: Moment of batch norm layers.
+    batch_norm_epsilon: Epsilon of batch borm layers.
+  Returns:
+    Output tensor for the block.
+  """
+  filters1, filters2, filters3 = filters
+  if tf.keras.backend.image_data_format() == 'channels_last':
+    bn_axis = 3
+  else:
+    bn_axis = 1
+  conv_name_base = 'res' + str(stage) + block + '_branch'
+  bn_name_base = 'bn' + str(stage) + block + '_branch'
+
+  x = layers.Conv2D(
+      filters1, (1, 1),
+      use_bias=False,
+      kernel_initializer='he_normal',
+      kernel_regularizer=_gen_l2_regularizer(use_l2_regularizer),
+      name=conv_name_base + '2a')(
+          input_tensor)
+  x = layers.BatchNormalization(
+      axis=bn_axis,
+      momentum=batch_norm_decay,
+      epsilon=batch_norm_epsilon,
+      name=bn_name_base + '2a')(
+          x)
+  x = layers.Activation('relu')(x)
+
+  x = layers.Conv2D(
+      filters2,
+      kernel_size,
+      padding='same',
+      use_bias=False,
+      kernel_initializer='he_normal',
+      kernel_regularizer=_gen_l2_regularizer(use_l2_regularizer),
+      name=conv_name_base + '2b')(
+          x)
+  x = layers.BatchNormalization(
+      axis=bn_axis,
+      momentum=batch_norm_decay,
+      epsilon=batch_norm_epsilon,
+      name=bn_name_base + '2b')(
+          x)
+  x = layers.Activation('relu')(x)
+
+  x = layers.Conv2D(
+      filters3, (1, 1),
+      use_bias=False,
+      kernel_initializer='he_normal',
+      kernel_regularizer=_gen_l2_regularizer(use_l2_regularizer),
+      name=conv_name_base + '2c')(
+          x)
+  x = layers.BatchNormalization(
+      axis=bn_axis,
+      momentum=batch_norm_decay,
+      epsilon=batch_norm_epsilon,
+      name=bn_name_base + '2c')(
+          x)
+
+  x = layers.add([x, input_tensor])
+  x = layers.Activation('relu')(x)
+  return x
+
+
+def conv_block(input_tensor,
+               kernel_size,
+               filters,
+               stage,
+               block,
+               strides=(2, 2),
+               use_l2_regularizer=True,
+               batch_norm_decay=0.9,
+               batch_norm_epsilon=1e-5):
+  """A block that has a conv layer at shortcut.
+  Note that from stage 3,
+  the second conv layer at main path is with strides=(2, 2)
+  And the shortcut should have strides=(2, 2) as well
+  Args:
+    input_tensor: input tensor
+    kernel_size: default 3, the kernel size of middle conv layer at main path
+    filters: list of integers, the filters of 3 conv layer at main path
+    stage: integer, current stage label, used for generating layer names
+    block: 'a','b'..., current block label, used for generating layer names
+    strides: Strides for the second conv layer in the block.
+    use_l2_regularizer: whether to use L2 regularizer on Conv layer.
+    batch_norm_decay: Moment of batch norm layers.
+    batch_norm_epsilon: Epsilon of batch borm layers.
+  Returns:
+    Output tensor for the block.
+  """
+  filters1, filters2, filters3 = filters
+  if tf.keras.backend.image_data_format() == 'channels_last':
+    bn_axis = 3
+  else:
+    bn_axis = 1
+  conv_name_base = 'res' + str(stage) + block + '_branch'
+  bn_name_base = 'bn' + str(stage) + block + '_branch'
+
+  x = layers.Conv2D(
+      filters1, (1, 1),
+      use_bias=False,
+      kernel_initializer='he_normal',
+      kernel_regularizer=_gen_l2_regularizer(use_l2_regularizer),
+      name=conv_name_base + '2a')(
+          input_tensor)
+  x = layers.BatchNormalization(
+      axis=bn_axis,
+      momentum=batch_norm_decay,
+      epsilon=batch_norm_epsilon,
+      name=bn_name_base + '2a')(
+          x)
+  x = layers.Activation('relu')(x)
+
+  x = layers.Conv2D(
+      filters2,
+      kernel_size,
+      strides=strides,
+      padding='same',
+      use_bias=False,
+      kernel_initializer='he_normal',
+      kernel_regularizer=_gen_l2_regularizer(use_l2_regularizer),
+      name=conv_name_base + '2b')(
+          x)
+  x = layers.BatchNormalization(
+      axis=bn_axis,
+      momentum=batch_norm_decay,
+      epsilon=batch_norm_epsilon,
+      name=bn_name_base + '2b')(
+          x)
+  x = layers.Activation('relu')(x)
+
+  x = layers.Conv2D(
+      filters3, (1, 1),
+      use_bias=False,
+      kernel_initializer='he_normal',
+      kernel_regularizer=_gen_l2_regularizer(use_l2_regularizer),
+      name=conv_name_base + '2c')(
+          x)
+  x = layers.BatchNormalization(
+      axis=bn_axis,
+      momentum=batch_norm_decay,
+      epsilon=batch_norm_epsilon,
+      name=bn_name_base + '2c')(
+          x)
+
+  shortcut = layers.Conv2D(
+      filters3, (1, 1),
+      strides=strides,
+      use_bias=False,
+      kernel_initializer='he_normal',
+      kernel_regularizer=_gen_l2_regularizer(use_l2_regularizer),
+      name=conv_name_base + '1')(
+          input_tensor)
+  shortcut = layers.BatchNormalization(
+      axis=bn_axis,
+      momentum=batch_norm_decay,
+      epsilon=batch_norm_epsilon,
+      name=bn_name_base + '1')(
+          shortcut)
+
+  x = layers.add([x, shortcut])
+  x = layers.Activation('relu')(x)
+  return x
+
+
+def resnet50(num_classes,
+             batch_size=None,
+             use_l2_regularizer=True,
+             rescale_inputs=False,
+             batch_norm_decay=0.9,
+             batch_norm_epsilon=1e-5):
+  """Instantiates the ResNet50 architecture.
+  Args:
+    num_classes: `int` number of classes for image classification.
+    batch_size: Size of the batches for each step.
+    use_l2_regularizer: whether to use L2 regularizer on Conv/Dense layer.
+    rescale_inputs: whether to rescale inputs from 0 to 1.
+    batch_norm_decay: Moment of batch norm layers.
+    batch_norm_epsilon: Epsilon of batch borm layers.
+  Returns:
+      A Keras model instance.
+  """
+  input_shape = (224, 224, 3)
+  img_input = layers.Input(shape=input_shape, batch_size=batch_size)
+  if rescale_inputs:
+    # Hub image modules expect inputs in the range [0, 1]. This rescales these
+    # inputs to the range expected by the trained model.
+    x = layers.Lambda(
+        lambda x: x * 255.0 - tf.keras.backend.constant(    # pylint: disable=g-long-lambda
+            imagenet_preprocessing.CHANNEL_MEANS,
+            shape=[1, 1, 3],
+            dtype=x.dtype),
+        name='rescale')(
+            img_input)
+  else:
+    x = img_input
+
+  if tf.keras.backend.image_data_format() == 'channels_first':
+    x = layers.Permute((3, 1, 2))(x)
+    bn_axis = 1
+  else:  # channels_last
+    bn_axis = 3
+
+  block_config = dict(
+      use_l2_regularizer=use_l2_regularizer,
+      batch_norm_decay=batch_norm_decay,
+      batch_norm_epsilon=batch_norm_epsilon)
+  x = layers.ZeroPadding2D(padding=(3, 3), name='conv1_pad')(x)
+  x = layers.Conv2D(
+      64, (7, 7),
+      strides=(2, 2),
+      padding='valid',
+      use_bias=False,
+      kernel_initializer='he_normal',
+      kernel_regularizer=_gen_l2_regularizer(use_l2_regularizer),
+      name='conv1')(
+          x)
+  x = layers.BatchNormalization(
+      axis=bn_axis,
+      momentum=batch_norm_decay,
+      epsilon=batch_norm_epsilon,
+      name='bn_conv1')(
+          x)
+  x = layers.Activation('relu')(x)
+  x = layers.MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
+
+  x = conv_block(
+      x, 3, [64, 64, 256], stage=2, block='a', strides=(1, 1), **block_config)
+  x = identity_block(x, 3, [64, 64, 256], stage=2, block='b', **block_config)
+  x = identity_block(x, 3, [64, 64, 256], stage=2, block='c', **block_config)
+
+  x = conv_block(x, 3, [128, 128, 512], stage=3, block='a', **block_config)
+  x = identity_block(x, 3, [128, 128, 512], stage=3, block='b', **block_config)
+  x = identity_block(x, 3, [128, 128, 512], stage=3, block='c', **block_config)
+  x = identity_block(x, 3, [128, 128, 512], stage=3, block='d', **block_config)
+
+  x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a', **block_config)
+  x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b', **block_config)
+  x = identity_block(x, 3, [256, 256, 1024], stage=4, block='c', **block_config)
+  x = identity_block(x, 3, [256, 256, 1024], stage=4, block='d', **block_config)
+  x = identity_block(x, 3, [256, 256, 1024], stage=4, block='e', **block_config)
+  x = identity_block(x, 3, [256, 256, 1024], stage=4, block='f', **block_config)
+
+  x = conv_block(x, 3, [512, 512, 2048], stage=5, block='a', **block_config)
+  x = identity_block(x, 3, [512, 512, 2048], stage=5, block='b', **block_config)
+  x = identity_block(x, 3, [512, 512, 2048], stage=5, block='c', **block_config)
+
+  x = layers.GlobalAveragePooling2D()(x)
+  x = layers.Dense(
+      num_classes,
+      kernel_initializer=tf.compat.v1.keras.initializers.random_normal(
+          stddev=0.01),
+      kernel_regularizer=_gen_l2_regularizer(use_l2_regularizer),
+      bias_regularizer=_gen_l2_regularizer(use_l2_regularizer),
+      name='fc1000')(
+          x)
+
+  # A softmax that is followed by the model loss must be done cannot be done
+  # in float16 due to numeric issues. So we pass dtype=float32.
+  x = layers.Activation('softmax', dtype='float32')(x)
+
+  # Create model.
+  return tf.keras.Model(img_input, x, name='resnet50')

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/implementations/TensorFlow/computer_vision/Resnets/resnet_keras/resnet_runnable.py

@@ -0,0 +1,545 @@
+# 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.
+# ==============================================================================
+# List of changes:
+# - added profiling callbacks support
+
+# Copyright (C) 2020-2021 Habana Labs, Ltd. an Intel Company
+
+"""Runs a ResNet model on the ImageNet dataset using custom training loops."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import json
+import os
+from typing import Dict, Optional, Text
+
+import tensorflow as tf
+from TensorFlow.common.modeling import performance
+from TensorFlow.common.training import grad_utils
+from TensorFlow.common.training import standard_runnable
+from TensorFlow.common.training import utils
+from TensorFlow.utils.flags import core as flags_core
+from TensorFlow.computer_vision.common import imagenet_preprocessing
+from TensorFlow.computer_vision.Resnets.resnet_keras import common
+from TensorFlow.computer_vision.Resnets.resnet_keras import resnet_model
+from TensorFlow.computer_vision.Resnets.resnet_keras.common import get_global_batch_size
+
+
+try:
+    import horovod.tensorflow as hvd
+except ImportError:
+    hvd = None
+class ResnetRunnable(standard_runnable.StandardTrainable,
+                     standard_runnable.StandardEvaluable):
+  """Implements the training and evaluation APIs for Resnet model."""
+
+  def __init__(self, flags_obj, time_callback, train_steps, epoch_steps, profiler_callback,mlperf_mlloger,mlperf_mllog):
+    standard_runnable.StandardTrainable.__init__(self,
+                                                 flags_obj.use_tf_while_loop,
+                                                 flags_obj.use_tf_function)
+    standard_runnable.StandardEvaluable.__init__(self,
+                                                 flags_obj.use_tf_function)
+
+    self.strategy = tf.distribute.get_strategy()
+    self.flags_obj = flags_obj
+    self.dtype = flags_core.get_tf_dtype(flags_obj)
+    self.time_callback = time_callback
+    self.profiler_callback = profiler_callback
+    self.first_step = True
+    self.warmup_train_dataset = None
+    self.warmup_train_iter = None
+    self.warmup_eval_dataset = None
+    self.warmup_eval_iter = None
+
+    self.mlperf_mlloger, self.mlperf_mllog = mlperf_mlloger, mlperf_mllog
+    # Input pipeline related
+    batch_size = flags_obj.batch_size
+    if batch_size % self.strategy.num_replicas_in_sync != 0:
+      raise ValueError(
+          'Batch size must be divisible by number of replicas : {}'.format(
+              self.strategy.num_replicas_in_sync))
+
+    # As auto rebatching is not supported in
+    # `experimental_distribute_datasets_from_function()` API, which is
+    # required when cloning dataset to multiple workers in eager mode,
+    # we use per-replica batch size.
+    self.batch_size = int(batch_size / self.strategy.num_replicas_in_sync)
+
+    if self.flags_obj.use_synthetic_data:
+      self.input_fn = self.get_synth_input_fn(True)
+    else:
+      self.input_fn = imagenet_preprocessing.input_fn
+
+    self.model = resnet_model.resnet50(
+        num_classes=imagenet_preprocessing.NUM_CLASSES,
+        batch_size=flags_obj.batch_size,
+        use_l2_regularizer=not flags_obj.single_l2_loss_op)
+
+    mlperf_variable_map = self.get_mlperf_variable_map()
+    for weight in self.model.weights:
+      if ('moving_mean' not in weight.name) and ('moving_variance' not in weight.name):
+        mlperf_mlloger.event(key=mlperf_mllog.constants.WEIGHTS_INITIALIZATION, metadata={'tensor': mlperf_variable_map[weight.name.split(':')[0]]})
+
+    self.use_lars_optimizer = self.flags_obj.optimizer == 'LARS'
+
+    self.optimizer = common.get_optimizer(flags_obj,
+                                          get_global_batch_size(flags_obj.batch_size),
+                                          train_steps,mlperf_mlloger,mlperf_mllog)
+    # Make sure iterations variable is created inside scope.
+    self.global_step = self.optimizer.iterations
+    self.train_steps = train_steps
+
+    self.one_hot = False
+    self.label_smoothing = flags_obj.label_smoothing
+    if self.label_smoothing and self.label_smoothing > 0:
+      self.one_hot = True
+
+    use_graph_rewrite = flags_obj.fp16_implementation == 'graph_rewrite'
+    if use_graph_rewrite and not flags_obj.use_tf_function:
+      raise ValueError('--fp16_implementation=graph_rewrite requires '
+                       '--use_tf_function to be true')
+    self.optimizer = performance.configure_optimizer(
+        self.optimizer,
+        use_float16=self.dtype == tf.float16,
+        use_graph_rewrite=use_graph_rewrite,
+        loss_scale=flags_core.get_loss_scale(flags_obj, default_for_fp16=128))
+
+    if self.flags_obj.report_accuracy_metrics:
+      self.train_loss = tf.keras.metrics.Mean('train_loss', dtype=tf.float32)
+      if self.one_hot:
+        self.train_accuracy = tf.keras.metrics.CategoricalAccuracy(
+            'train_accuracy', dtype=tf.float32)
+      else:
+        self.train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(
+            'train_accuracy', dtype=tf.float32)
+      self.test_loss = tf.keras.metrics.Mean('test_loss', dtype=tf.float32)
+    else:
+      self.train_loss = None
+      self.train_accuracy = None
+      self.test_loss = None
+
+    self.dist_eval = flags_obj.dist_eval
+    self.profile = flags_obj.profile
+
+    if self.one_hot:
+      self.test_accuracy = tf.keras.metrics.CategoricalAccuracy(
+          'test_accuracy', dtype=tf.float32)
+    else:
+      self.test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(
+          'test_accuracy', dtype=tf.float32)
+    self.eval_accuracy = 0
+
+    self.checkpoint = tf.train.Checkpoint(
+        model=self.model, optimizer=self.optimizer)
+
+    self.local_loss_mean = tf.keras.metrics.Mean("local_loss_min", dtype=tf.float32)
+
+    # Handling epochs.
+    self.epoch_steps = epoch_steps
+    self.epoch_helper = utils.EpochHelper(epoch_steps, self.global_step)
+
+    self.num_acc_steps = flags_obj.num_acc_steps
+    if self.num_acc_steps > 1:
+      self.init_accumulation_variables()
+
+    self.model_state = None
+
+  def init_accumulation_variables(self):
+    self.cur_acc_step = tf.compat.v1.get_variable(
+        name='cur_acc_step',
+        shape=(),
+        dtype=tf.int32,
+        trainable=False,
+        initializer=tf.compat.v1.constant_initializer(value=0)
+    )
+    self.accum_vars = [tf.compat.v1.get_variable(
+        name=tvar.name.split(':')[0] + '/accum',
+        shape=tvar.shape.as_list(),
+        dtype=tf.float32,
+        trainable=False,
+        initializer=tf.compat.v1.zeros_initializer()) for tvar in self.model.trainable_variables]
+    self.loss_acc = tf.compat.v1.get_variable(
+        name='loss_acc',
+        shape=(),
+        dtype=tf.float32,
+        trainable=False,
+        initializer=tf.compat.v1.constant_initializer(value=0.0)
+    )
+
+  def get_mlperf_variable_map(self):
+    try:
+      script_path = os.path.realpath(__file__)
+      head_tail = os.path.split(script_path)
+      mlperf_map_file = head_tail[0] + '/mlperf_variable_map.json'
+      with open(mlperf_map_file, mode='r') as file_handle:
+        json_content = file_handle.read()
+        mlperf_map = json.loads(json_content)
+    except IOError:
+      raise IOError(f"MLPerf variable map file: {mlperf_map_file} not accesible")
+    return mlperf_map
+
+  def get_synth_input_fn(self, is_training):
+    return common.get_synth_input_fn(
+          height=imagenet_preprocessing.DEFAULT_IMAGE_SIZE,
+          width=imagenet_preprocessing.DEFAULT_IMAGE_SIZE,
+          num_channels=imagenet_preprocessing.NUM_CHANNELS,
+          num_classes=imagenet_preprocessing.NUM_CLASSES,
+          dtype=common.get_dl_type(self.flags_obj),
+          drop_remainder=is_training,
+          experimental_preloading=self.flags_obj.experimental_preloading)
+
+  def build_train_dataset(self, synthetic=False, manifest_path=None):
+    """See base class."""
+    return utils.make_distributed_dataset(
+        self.strategy,
+        self.input_fn,
+        is_training=True,
+        data_dir=self.flags_obj.data_dir,
+        jpeg_data_dir=self.flags_obj.jpeg_data_dir,
+        batch_size=self.batch_size,
+        model_dir=self.flags_obj.model_dir,
+        parse_record_fn=imagenet_preprocessing.parse_record,
+        datasets_num_private_threads=self.flags_obj
+        .datasets_num_private_threads,
+        dtype=common.get_dl_type(self.flags_obj),
+        drop_remainder=True,
+        dataset_cache=self.flags_obj.dataset_cache,
+        experimental_preloading=self.flags_obj.experimental_preloading,
+        num_train_files=self.flags_obj.num_train_files,
+        num_eval_files=self.flags_obj.num_eval_files,
+        synthetic=synthetic,
+        manifest_path=manifest_path)
+
+  def build_synthetic_train_dataset(self):
+    return self.build_train_dataset(synthetic=True)
+
+  def build_eval_dataset(self, synthetic=False):
+    """See base class."""
+    return utils.make_distributed_dataset(
+        self.strategy,
+        self.input_fn,
+        is_training=False,
+        data_dir=self.flags_obj.data_dir,
+        jpeg_data_dir=self.flags_obj.jpeg_data_dir,
+        batch_size=self.batch_size,
+        model_dir=self.flags_obj.model_dir,
+        parse_record_fn=imagenet_preprocessing.parse_record,
+        dtype=common.get_dl_type(self.flags_obj),
+        dataset_cache=self.flags_obj.dataset_cache,
+        experimental_preloading=self.flags_obj.experimental_preloading,
+        num_train_files=self.flags_obj.num_train_files,
+        num_eval_files=self.flags_obj.num_eval_files,
+        synthetic=synthetic)
+
+  def build_synthetic_eval_dataset(self):
+    return self.build_eval_dataset(synthetic=True)
+
+  def get_prediction_loss(self, labels, logits, training=True):
+    if self.one_hot:
+      return tf.keras.losses.categorical_crossentropy(
+          labels, logits, label_smoothing=self.label_smoothing)
+    else:
+      return tf.keras.losses.sparse_categorical_crossentropy(labels, logits)
+
+  def train_loop_begin(self):
+    """See base class."""
+    # Reset all metrics
+    if self.train_loss:
+      self.train_loss.reset_states()
+    if self.train_accuracy:
+      self.train_accuracy.reset_states()
+
+    self._epoch_begin()
+    self.time_callback.on_batch_begin(self.epoch_helper.batch_index)
+    if self.profiler_callback is not None:
+      self.profiler_callback.on_batch_begin(self.epoch_helper.batch_index)
+
+  def train_step(self, iterator):
+    """See base class."""
+
+    def step_fn_broadcast():
+      if hvd is not None and hvd.is_initialized():
+        tf.cond(self.global_step == 1,
+              lambda: hvd.broadcast_variables(self.model.variables + self.optimizer.variables(), root_rank=0),
+              lambda: tf.constant(True))
+
+    def step_fn_modeling():
+      if self.flags_obj.modeling:
+        sess = tf.compat.v1.Session()
+        # pbtxt generation
+        tf.io.write_graph(sess.graph.as_graph_def(add_shapes=True), self.flags_obj.model_dir, 'graph.pbtxt')
+        # meta graph generation
+        tf.compat.v1.train.export_meta_graph(filename='checkpoint_model.meta', meta_info_def=None, graph_def=None, saver_def=None, collection_list=None, as_text=False, graph=None, export_scope=None, clear_devices=False, clear_extraneous_savers=False, strip_default_attrs=False, save_debug_info=False)
+
+    def step_fn_accumulation_steps_enabled(loss, tape):
+      grads = tape.gradient(loss, self.model.trainable_variables)
+
+      if self.cur_acc_step == 0:
+        for i in range(len(self.accum_vars)):
+          self.accum_vars[i].assign(grads[i])
+      else: # self.cur_acc_step > 0
+        for i in range(len(self.accum_vars)):
+          self.accum_vars[i].assign_add(grads[i])
+
+      self.loss_acc.assign_add(loss)
+      self.cur_acc_step.assign_add(1)
+
+      if self.cur_acc_step == self.num_acc_steps:
+        grads_and_vars = zip(self.accum_vars, self.model.trainable_variables)
+        self.optimizer.apply_gradients(grads_and_vars, experimental_aggregate_gradients=False)
+
+        step_fn_broadcast()
+        step_fn_modeling()
+
+        if self.train_loss:
+          self.train_loss.update_state(self.loss_acc)
+
+        self.cur_acc_step.assign(0)
+        self.loss_acc.assign(0.0)
+
+    def step_fn_accumulation_steps_disabled(loss, tape):
+      if hvd is not None and hvd.is_initialized():
+        grads = tape.gradient(loss, self.model.trainable_variables)
+        grads_and_vars = zip(grads, self.model.trainable_variables)
+        self.optimizer.apply_gradients(grads_and_vars, experimental_aggregate_gradients=False)
+      else:
+        grad_utils.minimize_using_explicit_allreduce(
+          tape, self.optimizer, loss, self.model.trainable_variables)
+
+      step_fn_broadcast()
+      step_fn_modeling()
+
+      if self.train_loss:
+        self.train_loss.update_state(loss)
+
+    def step_fn(inputs):
+      """Function to run on the device."""
+      images, labels = inputs
+      if self.one_hot:
+        labels = tf.cast(labels, tf.int32)
+        labels = tf.one_hot(labels, 1001)
+        labels = tf.squeeze(labels)
+
+      with tf.GradientTape() as tape:
+        logits = self.model(images, training=True)
+        prediction_loss = self.get_prediction_loss(labels, logits)
+        loss = tf.reduce_sum(prediction_loss) * (1.0 / self.flags_obj.batch_size)
+
+        if not self.use_lars_optimizer:
+          num_replicas = self.strategy.num_replicas_in_sync
+
+          if self.flags_obj.single_l2_loss_op:
+            l2_loss = self.flags_obj.weight_decay * tf.add_n([
+                tf.nn.l2_loss(v)
+                for v in self.model.trainable_variables
+                if ('bn' not in v.name)
+            ])
+
+            loss += (l2_loss / num_replicas)
+          else:
+            loss += (tf.reduce_sum(self.model.losses) / num_replicas)
+
+        loss = loss / self.num_acc_steps
+
+      if hvd is not None and hvd.is_initialized():
+        tape = hvd.DistributedGradientTape(tape)
+
+      if self.num_acc_steps > 1:
+        step_fn_accumulation_steps_enabled(loss, tape)
+      else:
+        step_fn_accumulation_steps_disabled(loss, tape)
+
+      if self.train_accuracy:
+        self.train_accuracy.update_state(labels, logits)
+
+    self.strategy.run(step_fn, args=(next(iterator),))
+
+  def train_loop_end(self):
+    """See base class."""
+    metrics = dict()
+    if self.train_loss:
+      metrics['train_loss'] = self.train_loss.result()
+    if self.train_accuracy:
+      metrics['train_accuracy'] = self.train_accuracy.result()
+    self.time_callback.on_batch_end(self.epoch_helper.batch_index - 1)
+    if self.profiler_callback is not None:
+      self.profiler_callback.on_batch_end(self.epoch_helper.batch_index - 1)
+    self._epoch_end()
+    return metrics
+
+  def eval_begin(self):
+    """See base class."""
+    if self.test_loss:
+      self.test_loss.reset_states()
+    self.test_accuracy.reset_states()
+    epoch_num = int(self.epoch_helper.current_epoch)
+    self.mlperf_mlloger.start(
+        key=self.mlperf_mllog.constants.EVAL_START, value=None, metadata={'epoch_num': epoch_num + 1})
+
+  def eval_step(self, iterator):
+    """See base class."""
+
+    def step_fn(inputs):
+      """Function to run on the device."""
+      images, labels = inputs
+      if self.one_hot:
+        labels = tf.cast(labels, tf.int32)
+        labels = tf.one_hot(labels, 1001)
+        labels = tf.squeeze(labels)
+
+      logits = self.model(images, training=False)
+      loss = self.get_prediction_loss(labels, logits, training=False)
+      loss = tf.reduce_sum(loss) * (1.0 / self.flags_obj.batch_size)
+      if self.test_loss:
+        self.test_loss.update_state(loss)
+      self.test_accuracy.update_state(labels, logits)
+
+    self.strategy.run(step_fn, args=(next(iterator),))
+
+  def eval_end(self):
+    """See base class."""
+    epoch_num = int(self.epoch_helper.current_epoch)
+    self.mlperf_mlloger.end(
+        key=self.mlperf_mllog.constants.EVAL_STOP, value=None, metadata={'epoch_num': epoch_num + 1})
+
+    local_hit = self.test_accuracy.total
+    local_count = self.test_accuracy.count
+
+    global_hit = local_hit
+    global_count = local_count
+    if hvd is not None and hvd.is_initialized() and self.dist_eval:
+        global_hit = hvd.allreduce(local_hit, op=hvd.Sum)
+        global_count = hvd.allreduce(local_count, op=hvd.Sum)
+    global_accuracy = float(global_hit / global_count)
+
+    # assign to self
+    self.test_accuracy.total.assign(global_hit)
+    self.test_accuracy.count.assign(global_count)
+
+    eval_accuracy = global_accuracy
+    self.eval_accuracy = eval_accuracy
+    self.mlperf_mlloger.event(
+        key=self.mlperf_mllog.constants.EVAL_ACCURACY, value=eval_accuracy, metadata={'epoch_num': epoch_num + 1})
+
+    first_epoch_num = max(epoch_num - self.flags_obj.epochs_between_evals + 1, 0)
+    epoch_count = self.flags_obj.epochs_between_evals
+    if first_epoch_num == 0:
+      epoch_count = self.flags_obj.eval_offset_epochs
+      if epoch_count == 0:
+        epoch_count = self.flags_obj.epochs_between_evals
+    self.mlperf_mlloger.end(
+        key=self.mlperf_mllog.constants.BLOCK_STOP,
+        value=None,
+        metadata={
+            'first_epoch_num': first_epoch_num + 1,
+            'epoch_count': epoch_count
+        })
+
+    past_threshold = False
+    if self.flags_obj.target_accuracy is not None:
+      past_threshold = eval_accuracy >= self.flags_obj.target_accuracy
+      if (hvd is not None and hvd.is_initialized() and (not self.dist_eval) ):
+          past_threshold = hvd.allreduce(tf.cast(past_threshold, tf.float32),
+                  op=hvd.Sum) > 0
+
+    continue_training = True
+    if past_threshold:
+      continue_training = False
+    elif ( (not self.profile) and eval_accuracy <= 0.002):
+      continue_training = False
+    elif self.global_step.numpy() < self.train_steps:
+      self.mlperf_mlloger.start(
+          key=self.mlperf_mllog.constants.BLOCK_START,
+          value=None,
+          metadata={
+              'first_epoch_num': epoch_num + 2,
+              'epoch_count': self.flags_obj.epochs_between_evals
+          })
+
+    metrics = {
+        'test_accuracy': eval_accuracy,
+        'continue_training': continue_training,
+    }
+    if self.test_loss:
+      metrics['test_loss'] = self.test_loss.result()
+    return metrics
+
+  def warmup(self, num_steps: Optional[tf.Tensor]) -> Optional[Dict[Text, tf.Tensor]]:
+    """Implements device warmup with multiple steps.
+
+    This loop runs the input pipeline on synthetic data before training, thereby
+    allowing tf.function tracing before the dataset is accessed.
+
+    Args:
+      num_steps: A guideline for how many training steps to run. Note that it is
+        up to the model what constitutes a "step" (this may involve more than
+        one update to model parameters, e.g. if training a GAN).
+
+    Returns:
+      The function may return a dictionary of `Tensors`, which will be
+      written to logs and as TensorBoard summaries.
+    """
+    self.model_state = [weight.numpy() for weight in self.model.weights]
+
+    if self.warmup_train_dataset is None:
+      self.warmup_train_dataset = self.build_synthetic_train_dataset()
+      self.warmup_train_iter = tf.nest.map_structure(iter, self.warmup_train_dataset)
+
+    if self.train_loop_fn is None:
+      train_fn = self.train_step
+      if self.use_tf_while_loop:
+        self.train_loop_fn = utils.create_tf_while_loop_fn(train_fn)
+      else:
+        if self.use_tf_function:
+          train_fn = tf.function(train_fn)
+        self.train_loop_fn = utils.create_loop_fn(train_fn)
+
+    self.train_loop_fn(self.warmup_train_iter, num_steps)
+
+    if self.warmup_eval_dataset is None:
+      self.warmup_eval_dataset = self.build_synthetic_eval_dataset()
+      self.warmup_eval_iter = tf.nest.map_structure(iter, self.warmup_eval_dataset)
+
+    if self.eval_loop_fn is None:
+      eval_fn = self.eval_step
+      if self.eval_use_tf_function:
+        eval_fn = tf.function(eval_fn)
+      self.eval_loop_fn = utils.create_loop_fn(eval_fn)
+
+    self.eval_loop_fn(self.warmup_eval_iter, num_steps)
+
+    return self.warmup_loop_end()
+
+  def warmup_loop_end(self):
+    """See base class."""
+    # Reset the state
+    for weight, state in zip(self.model.weights, self.model_state):
+      weight.assign(state)
+    for weight in self.optimizer.weights:
+      weight.assign(tf.zeros(shape=weight.shape, dtype=weight.dtype))
+
+  def _epoch_begin(self):
+    if self.epoch_helper.epoch_begin():
+      self.time_callback.on_epoch_begin(self.epoch_helper.current_epoch)
+      if self.profiler_callback is not None:
+        self.profiler_callback.on_epoch_begin(self.epoch_helper.current_epoch)
+
+  def _epoch_end(self):
+    if self.epoch_helper.epoch_end():
+      self.time_callback.on_epoch_end(self.epoch_helper.current_epoch)
+      if self.profiler_callback is not None:
+        self.profiler_callback.on_epoch_end(self.epoch_helper.current_epoch)

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

@@ -0,0 +1,680 @@
+# Copyright 2016 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.
+# ==============================================================================
+# List of changes:
+# - added support for prefetching to HPU
+# - flags to control image preprocessing
+# - flag to influence parallelism of dataset processing
+
+# Copyright (C) 2020-2021 Habana Labs, Ltd. an Intel Company
+
+
+"""Provides utilities to preprocess images.
+
+Training images are sampled using the provided bounding boxes, and subsequently
+cropped to the sampled bounding box. Images are additionally flipped randomly,
+then resized to the target output size (without aspect-ratio preservation).
+
+Images used during evaluation are resized (with aspect-ratio preservation) and
+centrally cropped.
+
+All images undergo mean color subtraction.
+
+Note that these steps are colloquially referred to as "ResNet preprocessing,"
+and they differ from "VGG preprocessing," which does not use bounding boxes
+and instead does an aspect-preserving resize followed by random crop during
+training. (These both differ from "Inception preprocessing," which introduces
+color distortion steps.)
+
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+import uuid
+from absl import flags
+from absl import logging
+import tensorflow as tf
+from habana_frameworks.tensorflow.media import habana_imagenet_dataset
+
+from habana_frameworks.tensorflow.multinode_helpers import comm_size
+
+try:
+    import horovod.tensorflow as hvd
+except ImportError:
+    hvd = None
+
+DEFAULT_IMAGE_SIZE = 224
+NUM_CHANNELS = 3
+NUM_CLASSES = 1001
+
+NUM_IMAGES = {
+    'train': 1281167,
+    'validation': 50000,
+}
+
+_SHUFFLE_BUFFER = 10000
+
+_R_MEAN = 123.68
+_G_MEAN = 116.78
+_B_MEAN = 103.94
+CHANNEL_MEANS = [_R_MEAN, _G_MEAN, _B_MEAN]
+
+# The lower bound for the smallest side of the image for aspect-preserving
+# resizing. For example, if an image is 500 x 1000, it will be resized to
+# _RESIZE_MIN x (_RESIZE_MIN * 2).
+_RESIZE_MIN = 256
+
+flags.DEFINE_integer(name='dataset_parallel_calls', default=tf.data.experimental.AUTOTUNE, help='Determines the number of parallel calls in dataset operations')
+
+
+def process_record_dataset(dataset,
+                           is_training,
+                           batch_size,
+                           shuffle_buffer,
+                           parse_record_fn,
+                           dtype=tf.float32,
+                           datasets_num_private_threads=None,
+                           drop_remainder=False,
+                           tf_data_experimental_slack=False,
+                           experimental_preloading=False):
+  """Given a Dataset with raw records, return an iterator over the records.
+
+  Args:
+    dataset: A Dataset representing raw records
+    is_training: A boolean denoting whether the input is for training.
+    batch_size: The number of samples per batch.
+    shuffle_buffer: The buffer size to use when shuffling records. A larger
+      value results in better randomness, but smaller values reduce startup
+      time and use less memory.
+    parse_record_fn: A function that takes a raw record and returns the
+      corresponding (image, label) pair.
+    dtype: Data type to use for images/features.
+    datasets_num_private_threads: Number of threads for a private
+      threadpool created for all datasets computation.
+    drop_remainder: A boolean indicates whether to drop the remainder of the
+      batches. If True, the batch dimension will be static.
+    tf_data_experimental_slack: Whether to enable tf.data's
+      `experimental_slack` option.
+
+  Returns:
+    Dataset of (image, label) pairs ready for iteration.
+  """
+  # Defines a specific size thread pool for tf.data operations.
+  if datasets_num_private_threads:
+    options = tf.data.Options()
+    options.experimental_threading.private_threadpool_size = (
+        datasets_num_private_threads)
+    dataset = dataset.with_options(options)
+    logging.info(
+        'datasets_num_private_threads: %s', datasets_num_private_threads)
+
+  if is_training:
+    # Shuffles records before repeating to respect epoch boundaries.
+    dataset = dataset.shuffle(buffer_size=shuffle_buffer)
+    # Repeats the dataset for the number of epochs to train.
+    dataset = dataset.repeat()
+
+  num_parallel_calls = flags.FLAGS.dataset_parallel_calls
+  if hvd is not None and hvd.is_initialized():
+      num_parallel_calls = 16
+  # Parses the raw records into images and labels.
+  dataset = dataset.map(
+      lambda value: parse_record_fn(value, is_training, dtype),
+      num_parallel_calls=num_parallel_calls, deterministic=False)
+  dataset = dataset.batch(batch_size, drop_remainder=drop_remainder)
+
+  # Operations between the final prefetch and the get_next call to the iterator
+  # will happen synchronously during run time. We prefetch here again to
+  # background all of the above processing work and keep it out of the
+  # critical training path. Setting buffer_size to tf.data.experimental.AUTOTUNE
+  # allows DistributionStrategies to adjust how many batches to fetch based
+  # on how many devices are present.
+  if experimental_preloading:
+    device = "/device:HPU:0"
+    with tf.device(device):
+        dataset = dataset.apply(tf.data.experimental.prefetch_to_device(device))
+  else:
+      dataset = dataset.prefetch(buffer_size=tf.data.experimental.AUTOTUNE)
+
+      options = tf.data.Options()
+      options.experimental_slack = tf_data_experimental_slack
+      dataset = dataset.with_options(options)
+
+  return dataset
+
+
+def get_filenames(is_training, data_dir, num_train_files, num_eval_files):
+  """Return filenames for dataset."""
+  if is_training:
+    return [
+        os.path.join(data_dir, 'train/train-%05d-of-%05d' % (i, num_train_files))
+        for i in range(num_train_files)]
+  else:
+    return [
+        os.path.join(data_dir, 'validation/validation-%05d-of-%05d' % (i, num_eval_files))
+        for i in range(num_eval_files)]
+
+
+def parse_example_proto(example_serialized):
+  """Parses an Example proto containing a training example of an image.
+
+  The output of the build_image_data.py image preprocessing script is a dataset
+  containing serialized Example protocol buffers. Each Example proto contains
+  the following fields (values are included as examples):
+
+    image/height: 462
+    image/width: 581
+    image/colorspace: 'RGB'
+    image/channels: 3
+    image/class/label: 615
+    image/class/synset: 'n03623198'
+    image/class/text: 'knee pad'
+    image/object/bbox/xmin: 0.1
+    image/object/bbox/xmax: 0.9
+    image/object/bbox/ymin: 0.2
+    image/object/bbox/ymax: 0.6
+    image/object/bbox/label: 615
+    image/format: 'JPEG'
+    image/filename: 'ILSVRC2012_val_00041207.JPEG'
+    image/encoded: <JPEG encoded string>
+
+  Args:
+    example_serialized: scalar Tensor tf.string containing a serialized
+      Example protocol buffer.
+
+  Returns:
+    image_buffer: Tensor tf.string containing the contents of a JPEG file.
+    label: Tensor tf.int32 containing the label.
+    bbox: 3-D float Tensor of bounding boxes arranged [1, num_boxes, coords]
+      where each coordinate is [0, 1) and the coordinates are arranged as
+      [ymin, xmin, ymax, xmax].
+  """
+  # Dense features in Example proto.
+  feature_map = {
+      'image/encoded': tf.io.FixedLenFeature([], dtype=tf.string,
+                                             default_value=''),
+      'image/class/label': tf.io.FixedLenFeature([], dtype=tf.int64,
+                                                 default_value=-1),
+      'image/class/text': tf.io.FixedLenFeature([], dtype=tf.string,
+                                                default_value=''),
+  }
+  sparse_float32 = tf.io.VarLenFeature(dtype=tf.float32)
+  # Sparse features in Example proto.
+  feature_map.update(
+      {k: sparse_float32 for k in [
+          'image/object/bbox/xmin', 'image/object/bbox/ymin',
+          'image/object/bbox/xmax', 'image/object/bbox/ymax']})
+
+  features = tf.io.parse_single_example(serialized=example_serialized,
+                                        features=feature_map)
+  label = tf.cast(features['image/class/label'], dtype=tf.int32)
+
+  xmin = tf.expand_dims(features['image/object/bbox/xmin'].values, 0)
+  ymin = tf.expand_dims(features['image/object/bbox/ymin'].values, 0)
+  xmax = tf.expand_dims(features['image/object/bbox/xmax'].values, 0)
+  ymax = tf.expand_dims(features['image/object/bbox/ymax'].values, 0)
+
+  # Note that we impose an ordering of (y, x) just to make life difficult.
+  bbox = tf.concat([ymin, xmin, ymax, xmax], 0)
+
+  # Force the variable number of bounding boxes into the shape
+  # [1, num_boxes, coords].
+  bbox = tf.expand_dims(bbox, 0)
+  bbox = tf.transpose(a=bbox, perm=[0, 2, 1])
+
+  return features['image/encoded'], label, bbox
+
+
+def parse_record(raw_record, is_training, dtype):
+  """Parses a record containing a training example of an image.
+
+  The input record is parsed into a label and image, and the image is passed
+  through preprocessing steps (cropping, flipping, and so on).
+
+  Args:
+    raw_record: scalar Tensor tf.string containing a serialized
+      Example protocol buffer.
+    is_training: A boolean denoting whether the input is for training.
+    dtype: data type to use for images/features.
+
+  Returns:
+    Tuple with processed image tensor in a channel-last format and
+    one-hot-encoded label tensor.
+  """
+  image_buffer, label, bbox = parse_example_proto(raw_record)
+
+  image = preprocess_image(
+      image_buffer=image_buffer,
+      bbox=bbox,
+      output_height=DEFAULT_IMAGE_SIZE,
+      output_width=DEFAULT_IMAGE_SIZE,
+      num_channels=NUM_CHANNELS,
+      is_training=is_training)
+  image = tf.cast(image, dtype)
+
+  # Subtract one so that labels are in [0, 1000), and cast to float32 for
+  # Keras model.
+  label = tf.cast(tf.cast(tf.reshape(label, shape=[1]), dtype=tf.int32) - 1,
+                  dtype=tf.float32)
+  return image, label
+
+
+def get_parse_record_fn(use_keras_image_data_format=False):
+  """Get a function for parsing the records, accounting for image format.
+
+  This is useful by handling different types of Keras models. For instance,
+  the current resnet_model.resnet50 input format is always channel-last,
+  whereas the keras_applications mobilenet input format depends on
+  tf.keras.backend.image_data_format(). We should set
+  use_keras_image_data_format=False for the former and True for the latter.
+
+  Args:
+    use_keras_image_data_format: A boolean denoting whether data format is keras
+      backend image data format. If False, the image format is channel-last. If
+      True, the image format matches tf.keras.backend.image_data_format().
+
+  Returns:
+    Function to use for parsing the records.
+  """
+  def parse_record_fn(raw_record, is_training, dtype):
+    image, label = parse_record(raw_record, is_training, dtype)
+    if use_keras_image_data_format:
+      if tf.keras.backend.image_data_format() == 'channels_first':
+        image = tf.transpose(image, perm=[2, 0, 1])
+    return image, label
+  return parse_record_fn
+
+
+def imagenet_dataset_fallback(is_training,
+                              data_dir,
+                              batch_size,
+                              dtype=tf.float32,
+                              datasets_num_private_threads=None,
+                              parse_record_fn=parse_record,
+                              input_context=None,
+                              drop_remainder=False,
+                              tf_data_experimental_slack=False,
+                              dataset_cache=True,
+                              filenames=None,
+                              experimental_preloading=False,
+                              num_train_files=1024,
+                              num_eval_files=128,
+                              use_distributed_eval=False):
+
+  if filenames is None:
+    filenames = get_filenames(is_training, data_dir, num_train_files, num_eval_files)
+  dataset = tf.data.Dataset.from_tensor_slices(filenames)
+
+  if (is_training or use_distributed_eval) and hvd is not None and hvd.is_initialized():
+    logging.info(
+      'HVD sharding the dataset: input_pipeline_id=%d num_input_pipelines=%d',
+      hvd.rank(), hvd.size())
+    dataset = dataset.shard(hvd.size(), hvd.rank())
+
+  if input_context:
+    logging.info(
+        'Sharding the dataset: input_pipeline_id=%d num_input_pipelines=%d',
+        input_context.input_pipeline_id, input_context.num_input_pipelines)
+    dataset = dataset.shard(input_context.num_input_pipelines,
+                            input_context.input_pipeline_id)
+
+  if is_training:
+    # Shuffle the input files
+    dataset = dataset.shuffle(buffer_size=num_train_files)
+
+  # Convert to individual records.
+  # cycle_length = 10 means that up to 10 files will be read and deserialized in
+  # parallel. You may want to increase this number if you have a large number of
+  # CPU cores.
+  cycle_length = 10
+  if hvd is not None and hvd.is_initialized():
+    if is_training:
+      cycle_length = num_train_files // comm_size()
+    else:
+      cycle_length = num_eval_files // comm_size()
+    cycle_length = min(cycle_length, 10)
+  dataset = dataset.interleave(
+      tf.data.TFRecordDataset,
+      cycle_length=cycle_length,
+      num_parallel_calls=flags.FLAGS.dataset_parallel_calls)
+
+  if dataset_cache:
+    # Improve performance when training and eval data is in remote storage and
+    # can fit into worker memory.
+    dataset = dataset.cache()
+
+  return process_record_dataset(
+      dataset=dataset,
+      is_training=is_training,
+      batch_size=batch_size,
+      shuffle_buffer=_SHUFFLE_BUFFER,
+      parse_record_fn=parse_record_fn,
+      dtype=dtype,
+      datasets_num_private_threads=datasets_num_private_threads,
+      drop_remainder=drop_remainder,
+      tf_data_experimental_slack=tf_data_experimental_slack,
+      experimental_preloading=experimental_preloading
+  )
+
+
+def fetch_synth_data(is_training: bool, batch_size: int, model_dir, dtype) -> str:
+  """A function that generates and stores synthetic data
+
+  Args:
+    is_training: A boolean denoting whether the input is for training.
+    batch_size: The number of samples per batch
+    dtype: Data type to use for images/features
+
+  Returns:
+    Path to synthetic data
+  """
+  root_path = f'{model_dir}/resnet_synth_data'
+  batch_class_name = f'{uuid.uuid4()}'
+  batch_path = f'{root_path}/train/{batch_class_name}/' if is_training else f'{root_path}/val/{batch_class_name}'
+
+  os.makedirs(batch_path, exist_ok=True)
+  for i in range(batch_size):
+    input = tf.random.truncated_normal([DEFAULT_IMAGE_SIZE, DEFAULT_IMAGE_SIZE, NUM_CHANNELS],
+                                          dtype=dtype,
+                                          mean=127,
+                                          stddev=60,
+                                          name='synthetic_inputs')
+    casted_input = tf.cast(input, tf.uint8).numpy()
+    encode = tf.image.encode_jpeg(casted_input, format='rgb', quality=95).numpy()
+    filename = f'{batch_class_name}_{i}.JPEG'
+    with open(f'{batch_path}/{filename}', 'w+b') as fd:
+      fd.write(encode)
+  return root_path
+
+def input_fn(is_training,
+             data_dir,
+             jpeg_data_dir,
+             batch_size,
+             model_dir,
+             dtype=tf.float32,
+             datasets_num_private_threads=None,
+             parse_record_fn=parse_record,
+             input_context=None,
+             drop_remainder=False,
+             tf_data_experimental_slack=False,
+             dataset_cache=True,
+             filenames=None,
+             experimental_preloading=False,
+             num_train_files=1024,
+             num_eval_files=128,
+             synthetic=False,
+             manifest_path=None):
+    """Input function which provides batches for train or eval.
+
+    Args:
+      is_training: A boolean denoting whether the input is for training.
+      data_dir: The directory containing the input data.
+      batch_size: The number of samples per batch.
+      dtype: Data type to use for images/features
+      datasets_num_private_threads: Number of private threads for tf.data.
+      parse_record_fn: Function to use for parsing the records.
+      input_context: A `tf.distribute.InputContext` object passed in by
+        `tf.distribute.Strategy`.
+      drop_remainder: A boolean indicates whether to drop the remainder of the
+        batches. If True, the batch dimension will be static.
+      tf_data_experimental_slack: Whether to enable tf.data's
+        `experimental_slack` option.
+      dataset_cache: Whether to cache the training and eval datasets on workers.
+         Typically used to improve performance when training and eval data is in
+         remote storage and can fit into worker memory.
+      filenames: Optional field for providing the file names of the TFRecords.
+      synthetic: A boolean that determines whether synthetic data should be generated.
+
+    Returns:
+      A dataset that can be used for iteration.
+    """
+    jpeg_data_path = fetch_synth_data(is_training, batch_size, model_dir, dtype) if synthetic else jpeg_data_dir
+    return habana_imagenet_dataset(fallback=imagenet_dataset_fallback,
+                                   is_training=is_training,
+                                   tf_data_dir=data_dir,
+                                   jpeg_data_dir=jpeg_data_path,
+                                   batch_size=batch_size,
+                                   num_channels=NUM_CHANNELS,
+                                   img_size=DEFAULT_IMAGE_SIZE,
+                                   dtype=dtype,
+                                   use_distributed_eval=flags.FLAGS.dist_eval,
+                                   datasets_num_private_threads=datasets_num_private_threads,
+                                   parse_record_fn=parse_record_fn,
+                                   input_context=input_context,
+                                   drop_remainder=drop_remainder,
+                                   tf_data_experimental_slack=tf_data_experimental_slack,
+                                   dataset_cache=dataset_cache,
+                                   filenames=filenames,
+                                   experimental_preloading=experimental_preloading,
+                                   num_train_files=num_train_files,
+                                   num_eval_files=num_eval_files,
+                                   use_pytorch_style_crop=True,
+                                   manifest_path=manifest_path)
+
+
+def _decode_crop_and_flip(image_buffer, bbox, num_channels):
+  """Crops the given image to a random part of the image, and randomly flips.
+
+  We use the fused decode_and_crop op, which performs better than the two ops
+  used separately in series, but note that this requires that the image be
+  passed in as an un-decoded string Tensor.
+
+  Args:
+    image_buffer: scalar string Tensor representing the raw JPEG image buffer.
+    bbox: 3-D float Tensor of bounding boxes arranged [1, num_boxes, coords]
+      where each coordinate is [0, 1) and the coordinates are arranged as
+      [ymin, xmin, ymax, xmax].
+    num_channels: Integer depth of the image buffer for decoding.
+
+  Returns:
+    3-D tensor with cropped image.
+
+  """
+  # A large fraction of image datasets contain a human-annotated bounding box
+  # delineating the region of the image containing the object of interest.  We
+  # choose to create a new bounding box for the object which is a randomly
+  # distorted version of the human-annotated bounding box that obeys an
+  # allowed range of aspect ratios, sizes and overlap with the human-annotated
+  # bounding box. If no box is supplied, then we assume the bounding box is
+  # the entire image.
+  sample_distorted_bounding_box = tf.image.sample_distorted_bounding_box(
+      tf.image.extract_jpeg_shape(image_buffer),
+      bounding_boxes=bbox,
+      min_object_covered=0.1,
+      aspect_ratio_range=[0.75, 1.33],
+      area_range=[0.05, 1.0],
+      max_attempts=100,
+      use_image_if_no_bounding_boxes=True)
+  bbox_begin, bbox_size, _ = sample_distorted_bounding_box
+
+  # Reassemble the bounding box in the format the crop op requires.
+  offset_y, offset_x, _ = tf.unstack(bbox_begin)
+  target_height, target_width, _ = tf.unstack(bbox_size)
+  crop_window = tf.stack([offset_y, offset_x, target_height, target_width])
+
+  # Use the fused decode and crop op here, which is faster than each in series.
+  cropped = tf.image.decode_and_crop_jpeg(
+      image_buffer, crop_window, channels=num_channels)
+
+  # Flip to add a little more random distortion in.
+  cropped = tf.image.random_flip_left_right(cropped)
+  return cropped
+
+
+def _central_crop(image, crop_height, crop_width):
+  """Performs central crops of the given image list.
+
+  Args:
+    image: a 3-D image tensor
+    crop_height: the height of the image following the crop.
+    crop_width: the width of the image following the crop.
+
+  Returns:
+    3-D tensor with cropped image.
+  """
+  shape = tf.shape(input=image)
+  height, width = shape[0], shape[1]
+
+  amount_to_be_cropped_h = (height - crop_height)
+  crop_top = amount_to_be_cropped_h // 2
+  amount_to_be_cropped_w = (width - crop_width)
+  crop_left = amount_to_be_cropped_w // 2
+  return tf.slice(
+      image, [crop_top, crop_left, 0], [crop_height, crop_width, -1])
+
+
+def _mean_image_subtraction(image, means, num_channels):
+  """Subtracts the given means from each image channel.
+
+  For example:
+    means = [123.68, 116.779, 103.939]
+    image = _mean_image_subtraction(image, means)
+
+  Note that the rank of `image` must be known.
+
+  Args:
+    image: a tensor of size [height, width, C].
+    means: a C-vector of values to subtract from each channel.
+    num_channels: number of color channels in the image that will be distorted.
+
+  Returns:
+    the centered image.
+
+  Raises:
+    ValueError: If the rank of `image` is unknown, if `image` has a rank other
+      than three or if the number of channels in `image` doesn't match the
+      number of values in `means`.
+  """
+  if image.get_shape().ndims != 3:
+    raise ValueError('Input must be of size [height, width, C>0]')
+
+  if len(means) != num_channels:
+    raise ValueError('len(means) must match the number of channels')
+
+  # We have a 1-D tensor of means; convert to 3-D.
+  # Note(b/130245863): we explicitly call `broadcast` instead of simply
+  # expanding dimensions for better performance.
+  means = tf.broadcast_to(means, tf.shape(image))
+
+  return image - means
+
+
+def _smallest_size_at_least(height, width, resize_min):
+  """Computes new shape with the smallest side equal to `smallest_side`.
+
+  Computes new shape with the smallest side equal to `smallest_side` while
+  preserving the original aspect ratio.
+
+  Args:
+    height: an int32 scalar tensor indicating the current height.
+    width: an int32 scalar tensor indicating the current width.
+    resize_min: A python integer or scalar `Tensor` indicating the size of
+      the smallest side after resize.
+
+  Returns:
+    new_height: an int32 scalar tensor indicating the new height.
+    new_width: an int32 scalar tensor indicating the new width.
+  """
+  resize_min = tf.cast(resize_min, tf.float32)
+
+  # Convert to floats to make subsequent calculations go smoothly.
+  height, width = tf.cast(height, tf.float32), tf.cast(width, tf.float32)
+
+  smaller_dim = tf.minimum(height, width)
+  scale_ratio = resize_min / smaller_dim
+
+  # Convert back to ints to make heights and widths that TF ops will accept.
+  new_height = tf.cast(height * scale_ratio, tf.int32)
+  new_width = tf.cast(width * scale_ratio, tf.int32)
+
+  return new_height, new_width
+
+
+def _aspect_preserving_resize(image, resize_min):
+  """Resize images preserving the original aspect ratio.
+
+  Args:
+    image: A 3-D image `Tensor`.
+    resize_min: A python integer or scalar `Tensor` indicating the size of
+      the smallest side after resize.
+
+  Returns:
+    resized_image: A 3-D tensor containing the resized image.
+  """
+  shape = tf.shape(input=image)
+  height, width = shape[0], shape[1]
+
+  new_height, new_width = _smallest_size_at_least(height, width, resize_min)
+
+  return _resize_image(image, new_height, new_width)
+
+
+def _resize_image(image, height, width):
+  """Simple wrapper around tf.resize_images.
+
+  This is primarily to make sure we use the same `ResizeMethod` and other
+  details each time.
+
+  Args:
+    image: A 3-D image `Tensor`.
+    height: The target height for the resized image.
+    width: The target width for the resized image.
+
+  Returns:
+    resized_image: A 3-D tensor containing the resized image. The first two
+      dimensions have the shape [height, width].
+  """
+  return tf.compat.v1.image.resize(
+      image, [height, width], method=tf.image.ResizeMethod.BILINEAR,
+      align_corners=False)
+
+
+def preprocess_image(image_buffer, bbox, output_height, output_width,
+                     num_channels, is_training=False):
+  """Preprocesses the given image.
+
+  Preprocessing includes decoding, cropping, and resizing for both training
+  and eval images. Training preprocessing, however, introduces some random
+  distortion of the image to improve accuracy.
+
+  Args:
+    image_buffer: scalar string Tensor representing the raw JPEG image buffer.
+    bbox: 3-D float Tensor of bounding boxes arranged [1, num_boxes, coords]
+      where each coordinate is [0, 1) and the coordinates are arranged as
+      [ymin, xmin, ymax, xmax].
+    output_height: The height of the image after preprocessing.
+    output_width: The width of the image after preprocessing.
+    num_channels: Integer depth of the image buffer for decoding.
+    is_training: `True` if we're preprocessing the image for training and
+      `False` otherwise.
+
+  Returns:
+    A preprocessed image.
+  """
+  if is_training:
+    # For training, we want to randomize some of the distortions.
+    image = _decode_crop_and_flip(image_buffer, bbox, num_channels)
+    image = _resize_image(image, output_height, output_width)
+  else:
+    # For validation, we want to decode, resize, then just crop the middle.
+    image = tf.image.decode_jpeg(image_buffer, channels=num_channels)
+    image = _aspect_preserving_resize(image, _RESIZE_MIN)
+    image = _central_crop(image, output_height, output_width)
+
+  image.set_shape([output_height, output_width, num_channels])
+
+  return _mean_image_subtraction(image, CHANNEL_MEANS, num_channels)

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/implementations/TensorFlow/utils/flags/_base.py

@@ -0,0 +1,168 @@
+# Copyright 2018 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.
+# ==============================================================================
+"""Flags which will be nearly universal across models."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from absl import flags
+import tensorflow as tf
+
+from TensorFlow.utils.flags._conventions import help_wrap
+from TensorFlow.utils.logs import hooks_helper
+
+
+def define_base(data_dir=True, model_dir=True, clean=False, train_epochs=False,
+                epochs_between_evals=False, stop_threshold=False,
+                batch_size=True, num_gpu=False, hooks=False, export_dir=False,
+                distribution_strategy=False, run_eagerly=False):
+  """Register base flags.
+
+  Args:
+    data_dir: Create a flag for specifying the input data directory.
+    model_dir: Create a flag for specifying the model file directory.
+    clean: Create a flag for removing the model_dir.
+    train_epochs: Create a flag to specify the number of training epochs.
+    epochs_between_evals: Create a flag to specify the frequency of testing.
+    stop_threshold: Create a flag to specify a threshold accuracy or other
+      eval metric which should trigger the end of training.
+    batch_size: Create a flag to specify the batch size.
+    num_gpu: Create a flag to specify the number of GPUs used.
+    hooks: Create a flag to specify hooks for logging.
+    export_dir: Create a flag to specify where a SavedModel should be exported.
+    distribution_strategy: Create a flag to specify which Distribution Strategy
+      to use.
+    run_eagerly: Create a flag to specify to run eagerly op by op.
+  Returns:
+    A list of flags for core.py to marks as key flags.
+  """
+  key_flags = []
+
+  if data_dir:
+    flags.DEFINE_string(
+        name="data_dir", short_name="dd", default="/tmp",
+        help=help_wrap("The location of the input data."))
+    key_flags.append("data_dir")
+
+    flags.DEFINE_string(
+        name="jpeg_data_dir", short_name="jpdd", default=None,
+        help=help_wrap("The location of the JPEG version of the input data. Used for media dataloader"))
+    key_flags.append("jpeg_data_dir")
+
+  if model_dir:
+    flags.DEFINE_string(
+        name="model_dir", short_name="md", default="/tmp",
+        help=help_wrap("The location of the model checkpoint files."))
+    key_flags.append("model_dir")
+
+  if clean:
+    flags.DEFINE_boolean(
+        name="clean", default=False,
+        help=help_wrap("If set, model_dir will be removed if it exists."))
+    key_flags.append("clean")
+
+  if train_epochs:
+    flags.DEFINE_integer(
+        name="train_epochs", short_name="te", default=1,
+        help=help_wrap("The number of epochs used to train."))
+    key_flags.append("train_epochs")
+
+  if epochs_between_evals:
+    flags.DEFINE_integer(
+        name="epochs_between_evals", short_name="ebe", default=1,
+        help=help_wrap("The number of training epochs to run between "
+                       "evaluations."))
+    key_flags.append("epochs_between_evals")
+
+  if stop_threshold:
+    flags.DEFINE_float(
+        name="stop_threshold", short_name="st",
+        default=None,
+        help=help_wrap("If passed, training will stop at the earlier of "
+                       "train_epochs and when the evaluation metric is  "
+                       "greater than or equal to stop_threshold."))
+
+  if batch_size:
+    flags.DEFINE_integer(
+        name="batch_size", short_name="bs", default=32,
+        help=help_wrap("Batch size for training and evaluation. When using "
+                       "multiple gpus, this is the global batch size for "
+                       "all devices. For example, if the batch size is 32 "
+                       "and there are 4 GPUs, each GPU will get 8 examples on "
+                       "each step."))
+    key_flags.append("batch_size")
+
+  if num_gpu:
+    flags.DEFINE_integer(
+        name="num_gpus", short_name="ng",
+        default=1,
+        help=help_wrap(
+            "How many GPUs to use at each worker with the "
+            "DistributionStrategies API. The default is 1."))
+
+  if run_eagerly:
+    flags.DEFINE_boolean(
+        name="run_eagerly", default=False,
+        help="Run the model op by op without building a model function.")
+
+  if hooks:
+    # Construct a pretty summary of hooks.
+    hook_list_str = (
+        u"\ufeff  Hook:\n" + u"\n".join([u"\ufeff    {}".format(key) for key
+                                         in hooks_helper.HOOKS]))
+    flags.DEFINE_list(
+        name="hooks", short_name="hk", default="LoggingTensorHook",
+        help=help_wrap(
+            u"A list of (case insensitive) strings to specify the names of "
+            u"training hooks.\n{}\n\ufeff  Example: `--hooks ProfilerHook,"
+            u"ExamplesPerSecondHook`\n See official.utils.logs.hooks_helper "
+            u"for details.".format(hook_list_str))
+    )
+    key_flags.append("hooks")
+
+  if export_dir:
+    flags.DEFINE_string(
+        name="export_dir", short_name="ed", default=None,
+        help=help_wrap("If set, a SavedModel serialization of the model will "
+                       "be exported to this directory at the end of training. "
+                       "See the README for more details and relevant links.")
+    )
+    key_flags.append("export_dir")
+
+  if distribution_strategy:
+    flags.DEFINE_string(
+        name="distribution_strategy", short_name="ds", default="mirrored",
+        help=help_wrap("The Distribution Strategy to use for training. "
+                       "Accepted values are 'off', 'one_device', "
+                       "'mirrored', 'parameter_server', 'collective', "
+                       "case insensitive. 'off' means not to use "
+                       "Distribution Strategy; 'default' means to choose "
+                       "from `MirroredStrategy` or `OneDeviceStrategy` "
+                       "according to the number of GPUs.")
+    )
+
+
+  return key_flags
+
+
+def get_num_gpus(flags_obj):
+  """Treat num_gpus=-1 as 'use all'."""
+  if flags_obj.num_gpus != -1:
+    return flags_obj.num_gpus
+
+  from tensorflow.python.client import device_lib  # pylint: disable=g-import-not-at-top
+  local_device_protos = device_lib.list_local_devices()
+  return sum([1 for d in local_device_protos if d.device_type == "GPU"])

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/implementations/TensorFlow/utils/flags/_device.py

@@ -0,0 +1,85 @@
+# Copyright 2018 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.
+# ==============================================================================
+"""Flags for managing compute devices. Currently only contains TPU flags."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from absl import flags
+import tensorflow as tf
+
+from TensorFlow.utils.flags._conventions import help_wrap
+
+
+def require_cloud_storage(flag_names):
+  """Register a validator to check directory flags.
+  Args:
+    flag_names: An iterable of strings containing the names of flags to be
+      checked.
+  """
+  msg = "TPU requires GCS path for {}".format(", ".join(flag_names))
+  @flags.multi_flags_validator(["tpu"] + flag_names, message=msg)
+  def _path_check(flag_values):  # pylint: disable=missing-docstring
+    if flag_values["tpu"] is None:
+      return True
+
+    valid_flags = True
+    for key in flag_names:
+      if not flag_values[key].startswith("gs://"):
+        tf.compat.v1.logging.error("{} must be a GCS path.".format(key))
+        valid_flags = False
+
+    return valid_flags
+
+
+def define_device(tpu=True):
+  """Register device specific flags.
+  Args:
+    tpu: Create flags to specify TPU operation.
+  Returns:
+    A list of flags for core.py to marks as key flags.
+  """
+
+  key_flags = []
+
+  if tpu:
+    flags.DEFINE_string(
+        name="tpu", default=None,
+        help=help_wrap(
+            "The Cloud TPU to use for training. This should be either the name "
+            "used when creating the Cloud TPU, or a "
+            "grpc://ip.address.of.tpu:8470 url. Passing `local` will use the"
+            "CPU of the local instance instead. (Good for debugging.)"))
+    key_flags.append("tpu")
+
+    flags.DEFINE_string(
+        name="tpu_zone", default=None,
+        help=help_wrap(
+            "[Optional] GCE zone where the Cloud TPU is located in. If not "
+            "specified, we will attempt to automatically detect the GCE "
+            "project from metadata."))
+
+    flags.DEFINE_string(
+        name="tpu_gcp_project", default=None,
+        help=help_wrap(
+            "[Optional] Project name for the Cloud TPU-enabled project. If not "
+            "specified, we will attempt to automatically detect the GCE "
+            "project from metadata."))
+
+    flags.DEFINE_integer(name="num_tpu_shards", default=8,
+                         help=help_wrap("Number of shards (TPU chips)."))
+
+  return key_flags

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/implementations/TensorFlow/utils/flags/_performance.py

@@ -0,0 +1,289 @@
+# Copyright 2018 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.
+# ==============================================================================
+"""Register flags for optimizing performance."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import multiprocessing
+
+from absl import flags    # pylint: disable=g-bad-import-order
+import tensorflow as tf   # pylint: disable=g-bad-import-order
+
+from TensorFlow.utils.flags._conventions import help_wrap
+
+
+# Map string to TensorFlow dtype
+DTYPE_MAP = {
+    "fp16": tf.float16,
+    "bf16": tf.bfloat16,
+    "fp32": tf.float32,
+}
+
+
+def get_tf_dtype(flags_obj):
+  if getattr(flags_obj, "fp16_implementation", None) == "graph_rewrite":
+    # If the graph_rewrite is used, we build the graph with fp32, and let the
+    # graph rewrite change ops to fp16.
+    return tf.float32
+  return DTYPE_MAP[flags_obj.dtype]
+
+
+def get_loss_scale(flags_obj, default_for_fp16):
+  dtype = get_tf_dtype(flags_obj)
+  if flags_obj.loss_scale == "dynamic":
+    return flags_obj.loss_scale
+  elif flags_obj.loss_scale is not None:
+    return float(flags_obj.loss_scale)
+  elif dtype == tf.float32 or dtype == tf.bfloat16:
+    return 1  # No loss scaling is needed for fp32
+  else:
+    assert dtype == tf.float16
+    return default_for_fp16
+
+
+def define_performance(num_parallel_calls=False, inter_op=False, intra_op=False,
+                       synthetic_data=False, max_train_steps=False, dtype=False,
+                       all_reduce_alg=False, num_packs=False,
+                       tf_gpu_thread_mode=False,
+                       datasets_num_private_threads=False,
+                       datasets_num_parallel_batches=False,
+                       dynamic_loss_scale=False, fp16_implementation=False,
+                       loss_scale=False,
+                       tf_data_experimental_slack=False, enable_xla=False,
+                       dataset_cache=True):
+  """Register flags for specifying performance tuning arguments.
+
+  Args:
+    num_parallel_calls: Create a flag to specify parallelism of data loading.
+    inter_op: Create a flag to allow specification of inter op threads.
+    intra_op: Create a flag to allow specification of intra op threads.
+    synthetic_data: Create a flag to allow the use of synthetic data.
+    max_train_steps: Create a flags to allow specification of maximum number
+      of training steps
+    dtype: Create flags for specifying dtype.
+    all_reduce_alg: If set forces a specific algorithm for multi-gpu.
+    num_packs: If set provides number of packs for MirroredStrategy's cross
+      device ops.
+    tf_gpu_thread_mode: gpu_private triggers us of private thread pool.
+    datasets_num_private_threads: Number of private threads for datasets.
+    datasets_num_parallel_batches: Determines how many batches to process in
+    parallel when using map and batch from tf.data.
+    dynamic_loss_scale: Allow the "loss_scale" flag to take on the value
+      "dynamic". Only valid if `dtype` is True.
+    fp16_implementation: Create fp16_implementation flag.
+    loss_scale: Controls the loss scaling, normally for mixed-precision
+      training. Can only be turned on if dtype is also True.
+    tf_data_experimental_slack: Determines whether to enable tf.data's
+      `experimental_slack` option.
+    enable_xla: Determines if XLA (auto clustering) is turned on.
+    dataset_cache: Whether to cache the training and eval dataset on workers.
+       Typically used to improve training performance when training data is in
+       remote storage and can fit into worker memory.
+
+  Returns:
+    A list of flags for core.py to marks as key flags.
+  """
+
+  key_flags = []
+  if num_parallel_calls:
+    flags.DEFINE_integer(
+        name="num_parallel_calls", short_name="npc",
+        default=multiprocessing.cpu_count(),
+        help=help_wrap("The number of records that are  processed in parallel "
+                       "during input processing. This can be optimized per "
+                       "data set but for generally homogeneous data sets, "
+                       "should be approximately the number of available CPU "
+                       "cores. (default behavior)"))
+
+  if inter_op:
+    flags.DEFINE_integer(
+        name="inter_op_parallelism_threads", short_name="inter", default=0,
+        help=help_wrap("Number of inter_op_parallelism_threads to use for CPU. "
+                       "See TensorFlow config.proto for details.")
+    )
+
+  if intra_op:
+    flags.DEFINE_integer(
+        name="intra_op_parallelism_threads", short_name="intra", default=0,
+        help=help_wrap("Number of intra_op_parallelism_threads to use for CPU. "
+                       "See TensorFlow config.proto for details."))
+
+  if synthetic_data:
+    flags.DEFINE_bool(
+        name="use_synthetic_data", short_name="synth", default=False,
+        help=help_wrap(
+            "If set, use fake data (zeroes) instead of a real dataset. "
+            "This mode is useful for performance debugging, as it removes "
+            "input processing steps, but will not learn anything."))
+
+  if max_train_steps:
+    flags.DEFINE_integer(
+        name="max_train_steps", short_name="mts", default=None, help=help_wrap(
+            "The model will stop training if the global_step reaches this "
+            "value. If not set, training will run until the specified number "
+            "of epochs have run as usual. It is generally recommended to set "
+            "--train_epochs=1 when using this flag."
+        ))
+
+  if dtype:
+    flags.DEFINE_enum(
+        name="dtype", short_name="dt", default="fp32",
+        enum_values=DTYPE_MAP.keys(),
+        help=help_wrap("The TensorFlow datatype used for calculations. "
+                       "Variables may be cast to a higher precision on a "
+                       "case-by-case basis for numerical stability."))
+
+    loss_scale_help_text = (
+        "The amount to scale the loss by when the model is run. {}. Before "
+        "gradients are computed, the loss is multiplied by the loss scale, "
+        "making all gradients loss_scale times larger. To adjust for this, "
+        "gradients are divided by the loss scale before being applied to "
+        "variables. This is mathematically equivalent to training without "
+        "a loss scale, but the loss scale helps avoid some intermediate "
+        "gradients from underflowing to zero. If not provided the default "
+        "for fp16 is 128 and 1 for all other dtypes.{}"
+    )
+    if dynamic_loss_scale:
+      loss_scale_help_text = loss_scale_help_text.format(
+          "This can be an int/float or the string 'dynamic'",
+          " The string 'dynamic' can be used to dynamically determine the "
+          "optimal loss scale during training, but currently this "
+          "significantly slows down performance")
+      loss_scale_validation_msg = ("loss_scale should be a positive int/float "
+                                   "or the string 'dynamic'.")
+    else:
+      loss_scale_help_text = loss_scale_help_text.format(
+          "This must be an int/float", "")
+      loss_scale_validation_msg = "loss_scale should be a positive int/float."
+    if loss_scale:
+      flags.DEFINE_string(
+          name="loss_scale", short_name="ls", default=None,
+          help=help_wrap(loss_scale_help_text))
+
+      @flags.validator(flag_name="loss_scale",
+                       message=loss_scale_validation_msg)
+      def _check_loss_scale(loss_scale):  # pylint: disable=unused-variable
+        """Validator to check the loss scale flag is valid."""
+        if loss_scale is None:
+          return True  # null case is handled in get_loss_scale()
+
+        if loss_scale == "dynamic" and dynamic_loss_scale:
+          return True
+
+        try:
+          loss_scale = float(loss_scale)
+        except ValueError:
+          return False
+
+        return loss_scale > 0
+
+    if fp16_implementation:
+      flags.DEFINE_enum(
+          name="fp16_implementation", default="keras",
+          enum_values=("keras', 'graph_rewrite"),
+          help=help_wrap(
+              "When --dtype=fp16, how fp16 should be implemented. This has no "
+              "impact on correctness. 'keras' uses the "
+              "tf.keras.mixed_precision API. 'graph_rewrite' uses the "
+              "tf.compat.v1.mixed_precision.enable_mixed_precision_graph_rewrite "
+              "API."))
+
+      @flags.multi_flags_validator(["fp16_implementation", "dtype",
+                                    "loss_scale"])
+      def _check_fp16_implementation(flags_dict):
+        """Validator to check fp16_implementation flag is valid."""
+        if (flags_dict["fp16_implementation"] == "graph_rewrite" and
+            flags_dict["dtype"] != "fp16"):
+          raise flags.ValidationError("--fp16_implementation should not be "
+                                      "specified unless --dtype=fp16")
+        return True
+
+  if all_reduce_alg:
+    flags.DEFINE_string(
+        name="all_reduce_alg", short_name="ara", default=None,
+        help=help_wrap("Defines the algorithm to use for performing all-reduce."
+                       "When specified with MirroredStrategy for single "
+                       "worker, this controls "
+                       "tf.contrib.distribute.AllReduceCrossTowerOps.  When "
+                       "specified with MultiWorkerMirroredStrategy, this "
+                       "controls "
+                       "tf.distribute.experimental.CollectiveCommunication; "
+                       "valid options are `ring` and `nccl`."))
+
+  if num_packs:
+    flags.DEFINE_integer(
+        name="num_packs", default=1,
+        help=help_wrap("Sets `num_packs` in the cross device ops used in "
+                       "MirroredStrategy.  For details, see "
+                       "tf.distribute.NcclAllReduce."))
+
+  if tf_gpu_thread_mode:
+    flags.DEFINE_string(
+        name="tf_gpu_thread_mode", short_name="gt_mode", default=None,
+        help=help_wrap(
+            "Whether and how the GPU device uses its own threadpool.")
+    )
+
+    flags.DEFINE_integer(
+        name="per_gpu_thread_count", short_name="pgtc", default=0,
+        help=help_wrap(
+            "The number of threads to use for GPU. Only valid when "
+            "tf_gpu_thread_mode is not global.")
+    )
+
+  if datasets_num_private_threads:
+    flags.DEFINE_integer(
+        name="datasets_num_private_threads",
+        default=None,
+        help=help_wrap(
+            "Number of threads for a private threadpool created for all"
+            "datasets computation..")
+    )
+
+  if datasets_num_parallel_batches:
+    flags.DEFINE_integer(
+        name="datasets_num_parallel_batches",
+        default=None,
+        help=help_wrap(
+            "Determines how many batches to process in parallel when using "
+            "map and batch from tf.data.")
+    )
+
+  if dataset_cache:
+    flags.DEFINE_boolean(
+        name="dataset_cache",
+        default=True,
+        help=help_wrap(
+            "Determines whether to cache the training and eval dataset on workers. "
+            "Typically used to improve training performance when training and eval "
+            "data is in remote storage and can fit into worker memory.")
+    )
+
+  if tf_data_experimental_slack:
+    flags.DEFINE_boolean(
+        name="tf_data_experimental_slack",
+        default=False,
+        help=help_wrap(
+            "Whether to enable tf.data's `experimental_slack` option.")
+    )
+
+  if enable_xla:
+    flags.DEFINE_boolean(
+        name="enable_xla", default=False,
+        help="Whether to enable XLA auto jit compilation")
+
+  return key_flags

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/implementations/TensorFlow/utils/flags/core.py

@@ -0,0 +1,133 @@
+# Copyright 2018 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.
+# ==============================================================================
+"""Public interface for flag definition.
+
+See _example.py for detailed instructions on defining flags.
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import sys
+from six.moves import shlex_quote
+
+from absl import app as absl_app
+from absl import flags
+
+from TensorFlow.utils.flags import _base
+from TensorFlow.utils.flags import _benchmark
+from TensorFlow.utils.flags import _conventions
+from TensorFlow.utils.flags import _device
+from TensorFlow.utils.flags import _distribution
+from TensorFlow.utils.flags import _misc
+from TensorFlow.utils.flags import _performance
+
+
+def set_defaults(**kwargs):
+  for key, value in kwargs.items():
+    flags.FLAGS.set_default(name=key, value=value)
+
+
+def parse_flags(argv=None):
+  """Reset flags and reparse. Currently only used in testing."""
+  flags.FLAGS.unparse_flags()
+  absl_app.parse_flags_with_usage(argv or sys.argv)
+
+
+def register_key_flags_in_core(f):
+  """Defines a function in core.py, and registers its key flags.
+
+  absl uses the location of a flags.declare_key_flag() to determine the context
+  in which a flag is key. By making all declares in core, this allows model
+  main functions to call flags.adopt_module_key_flags() on core and correctly
+  chain key flags.
+
+  Args:
+    f:  The function to be wrapped
+
+  Returns:
+    The "core-defined" version of the input function.
+  """
+
+  def core_fn(*args, **kwargs):
+    key_flags = f(*args, **kwargs)
+    [flags.declare_key_flag(fl) for fl in key_flags]  # pylint: disable=expression-not-assigned
+  return core_fn
+
+
+define_base = register_key_flags_in_core(_base.define_base)
+# We have define_base_eager for compatibility, since it used to be a separate
+# function from define_base.
+define_base_eager = define_base
+define_log_steps = register_key_flags_in_core(_benchmark.define_log_steps)
+define_benchmark = register_key_flags_in_core(_benchmark.define_benchmark)
+define_device = register_key_flags_in_core(_device.define_device)
+define_image = register_key_flags_in_core(_misc.define_image)
+define_performance = register_key_flags_in_core(_performance.define_performance)
+define_distribution = register_key_flags_in_core(
+    _distribution.define_distribution)
+
+
+help_wrap = _conventions.help_wrap
+
+
+get_num_gpus = _base.get_num_gpus
+get_tf_dtype = _performance.get_tf_dtype
+get_loss_scale = _performance.get_loss_scale
+DTYPE_MAP = _performance.DTYPE_MAP
+require_cloud_storage = _device.require_cloud_storage
+
+def _get_nondefault_flags_as_dict():
+  """Returns the nondefault flags as a dict from flag name to value."""
+  nondefault_flags = {}
+  for flag_name in flags.FLAGS:
+    flag_value = getattr(flags.FLAGS, flag_name)
+    if (flag_name != flags.FLAGS[flag_name].short_name and
+        flag_value != flags.FLAGS[flag_name].default):
+      nondefault_flags[flag_name] = flag_value
+  return nondefault_flags
+
+
+def get_nondefault_flags_as_str():
+  """Returns flags as a string that can be passed as command line arguments.
+
+  E.g., returns: "--batch_size=256 --use_synthetic_data" for the following code
+  block:
+
+  ```
+  flags.FLAGS.batch_size = 256
+  flags.FLAGS.use_synthetic_data = True
+  print(get_nondefault_flags_as_str())
+  ```
+
+  Only flags with nondefault values are returned, as passing default flags as
+  command line arguments has no effect.
+
+  Returns:
+    A string with the flags, that can be passed as command line arguments to a
+    program to use the flags.
+  """
+  nondefault_flags = _get_nondefault_flags_as_dict()
+  flag_strings = []
+  for name, value in sorted(nondefault_flags.items()):
+    if isinstance(value, bool):
+      flag_str = '--{}'.format(name) if value else '--no{}'.format(name)
+    elif isinstance(value, list):
+      flag_str = '--{}={}'.format(name, ','.join(value))
+    else:
+      flag_str = '--{}={}'.format(name, value)
+    flag_strings.append(flag_str)
+  return ' '.join(shlex_quote(flag_str) for flag_str in flag_strings)

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/implementations/TensorFlow/utils/logs/cloud_lib.py

@@ -0,0 +1,34 @@
+# Copyright 2018 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.
+# ==============================================================================
+
+"""Utilities that interact with cloud service.
+"""
+
+import requests
+
+GCP_METADATA_URL = "http://metadata/computeMetadata/v1/instance/hostname"
+GCP_METADATA_HEADER = {"Metadata-Flavor": "Google"}
+
+
+def on_gcp():
+  """Detect whether the current running environment is on GCP."""
+  try:
+    # Timeout in 5 seconds, in case the test environment has connectivity issue.
+    # There is not default timeout, which means it might block forever.
+    response = requests.get(
+        GCP_METADATA_URL, headers=GCP_METADATA_HEADER, timeout=5)
+    return response.status_code == 200
+  except requests.exceptions.RequestException:
+    return False

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/implementations/TensorFlow/utils/logs/hooks.py

@@ -0,0 +1,130 @@
+# Copyright 2017 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.
+# ==============================================================================
+
+"""Hook that counts examples per second every N steps or seconds."""
+
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import tensorflow as tf  # pylint: disable=g-bad-import-order
+
+from TensorFlow.utils.logs import logger
+
+
+class ExamplesPerSecondHook(tf.estimator.SessionRunHook):
+  """Hook to print out examples per second.
+
+  Total time is tracked and then divided by the total number of steps
+  to get the average step time and then batch_size is used to determine
+  the running average of examples per second. The examples per second for the
+  most recent interval is also logged.
+  """
+
+  def __init__(self,
+               batch_size,
+               every_n_steps=None,
+               every_n_secs=None,
+               warm_steps=0,
+               metric_logger=None):
+    """Initializer for ExamplesPerSecondHook.
+
+    Args:
+      batch_size: Total batch size across all workers used to calculate
+        examples/second from global time.
+      every_n_steps: Log stats every n steps.
+      every_n_secs: Log stats every n seconds. Exactly one of the
+        `every_n_steps` or `every_n_secs` should be set.
+      warm_steps: The number of steps to be skipped before logging and running
+        average calculation. warm_steps steps refers to global steps across all
+        workers, not on each worker
+      metric_logger: instance of `BenchmarkLogger`, the benchmark logger that
+          hook should use to write the log. If None, BaseBenchmarkLogger will
+          be used.
+
+    Raises:
+      ValueError: if neither `every_n_steps` or `every_n_secs` is set, or
+      both are set.
+    """
+
+    if (every_n_steps is None) == (every_n_secs is None):
+      raise ValueError("exactly one of every_n_steps"
+                       " and every_n_secs should be provided.")
+
+    self._logger = metric_logger or logger.BaseBenchmarkLogger()
+
+    self._timer = tf.estimator.SecondOrStepTimer(
+        every_steps=every_n_steps, every_secs=every_n_secs)
+
+    self._step_train_time = 0
+    self._total_steps = 0
+    self._batch_size = batch_size
+    self._warm_steps = warm_steps
+    # List of examples per second logged every_n_steps.
+    self.current_examples_per_sec_list = []
+
+  def begin(self):
+    """Called once before using the session to check global step."""
+    self._global_step_tensor = tf.compat.v1.train.get_global_step()
+    if self._global_step_tensor is None:
+      raise RuntimeError(
+          "Global step should be created to use StepCounterHook.")
+
+  def before_run(self, run_context):  # pylint: disable=unused-argument
+    """Called before each call to run().
+
+    Args:
+      run_context: A SessionRunContext object.
+
+    Returns:
+      A SessionRunArgs object or None if never triggered.
+    """
+    return tf.estimator.SessionRunArgs(self._global_step_tensor)
+
+  def after_run(self, run_context, run_values):  # pylint: disable=unused-argument
+    """Called after each call to run().
+
+    Args:
+      run_context: A SessionRunContext object.
+      run_values: A SessionRunValues object.
+    """
+    global_step = run_values.results
+
+    if self._timer.should_trigger_for_step(
+        global_step) and global_step > self._warm_steps:
+      elapsed_time, elapsed_steps = self._timer.update_last_triggered_step(
+          global_step)
+      if elapsed_time is not None:
+        self._step_train_time += elapsed_time
+        self._total_steps += elapsed_steps
+
+        # average examples per second is based on the total (accumulative)
+        # training steps and training time so far
+        average_examples_per_sec = self._batch_size * (
+            self._total_steps / self._step_train_time)
+        # current examples per second is based on the elapsed training steps
+        # and training time per batch
+        current_examples_per_sec = self._batch_size * (
+            elapsed_steps / elapsed_time)
+        # Logs entries to be read from hook during or after run.
+        self.current_examples_per_sec_list.append(current_examples_per_sec)
+        self._logger.log_metric(
+            "average_examples_per_sec", average_examples_per_sec,
+            global_step=global_step)
+
+        self._logger.log_metric(
+            "current_examples_per_sec", current_examples_per_sec,
+            global_step=global_step)

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/implementations/TensorFlow/utils/logs/hooks_helper.py

@@ -0,0 +1,172 @@
+# Copyright 2017 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.
+# ==============================================================================
+
+"""Hooks helper to return a list of TensorFlow hooks for training by name.
+
+More hooks can be added to this set. To add a new hook, 1) add the new hook to
+the registry in HOOKS, 2) add a corresponding function that parses out necessary
+parameters.
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import tensorflow as tf  # pylint: disable=g-bad-import-order
+
+from TensorFlow.utils.logs import hooks
+from TensorFlow.utils.logs import logger
+from TensorFlow.utils.logs import metric_hook
+
+_TENSORS_TO_LOG = dict((x, x) for x in ['learning_rate',
+                                        'cross_entropy',
+                                        'train_accuracy'])
+
+
+def get_train_hooks(name_list, use_tpu=False, **kwargs):
+  """Factory for getting a list of TensorFlow hooks for training by name.
+
+  Args:
+    name_list: a list of strings to name desired hook classes. Allowed:
+      LoggingTensorHook, ProfilerHook, ExamplesPerSecondHook, which are defined
+      as keys in HOOKS
+    use_tpu: Boolean of whether computation occurs on a TPU. This will disable
+      hooks altogether.
+    **kwargs: a dictionary of arguments to the hooks.
+
+  Returns:
+    list of instantiated hooks, ready to be used in a classifier.train call.
+
+  Raises:
+    ValueError: if an unrecognized name is passed.
+  """
+
+  if not name_list:
+    return []
+
+  if use_tpu:
+    tf.compat.v1.logging.warning('hooks_helper received name_list `{}`, but a '
+                                 'TPU is specified. No hooks will be used.'
+                                 .format(name_list))
+    return []
+
+  train_hooks = []
+  for name in name_list:
+    hook_name = HOOKS.get(name.strip().lower())
+    if hook_name is None:
+      raise ValueError('Unrecognized training hook requested: {}'.format(name))
+    else:
+      train_hooks.append(hook_name(**kwargs))
+
+  return train_hooks
+
+
+def get_logging_tensor_hook(every_n_iter=100, tensors_to_log=None, **kwargs):  # pylint: disable=unused-argument
+  """Function to get LoggingTensorHook.
+
+  Args:
+    every_n_iter: `int`, print the values of `tensors` once every N local
+      steps taken on the current worker.
+    tensors_to_log: List of tensor names or dictionary mapping labels to tensor
+      names. If not set, log _TENSORS_TO_LOG by default.
+    **kwargs: a dictionary of arguments to LoggingTensorHook.
+
+  Returns:
+    Returns a LoggingTensorHook with a standard set of tensors that will be
+    printed to stdout.
+  """
+  if tensors_to_log is None:
+    tensors_to_log = _TENSORS_TO_LOG
+
+  return tf.estimator.LoggingTensorHook(
+      tensors=tensors_to_log,
+      every_n_iter=every_n_iter)
+
+
+def get_profiler_hook(model_dir, save_steps=1000, **kwargs):  # pylint: disable=unused-argument
+  """Function to get ProfilerHook.
+
+  Args:
+    model_dir: The directory to save the profile traces to.
+    save_steps: `int`, print profile traces every N steps.
+    **kwargs: a dictionary of arguments to ProfilerHook.
+
+  Returns:
+    Returns a ProfilerHook that writes out timelines that can be loaded into
+    profiling tools like chrome://tracing.
+  """
+  return tf.estimator.ProfilerHook(save_steps=save_steps, output_dir=model_dir)
+
+
+def get_examples_per_second_hook(every_n_steps=100,
+                                 batch_size=128,
+                                 warm_steps=5,
+                                 **kwargs):  # pylint: disable=unused-argument
+  """Function to get ExamplesPerSecondHook.
+
+  Args:
+    every_n_steps: `int`, print current and average examples per second every
+      N steps.
+    batch_size: `int`, total batch size used to calculate examples/second from
+      global time.
+    warm_steps: skip this number of steps before logging and running average.
+    **kwargs: a dictionary of arguments to ExamplesPerSecondHook.
+
+  Returns:
+    Returns a ProfilerHook that writes out timelines that can be loaded into
+    profiling tools like chrome://tracing.
+  """
+  return hooks.ExamplesPerSecondHook(
+      batch_size=batch_size, every_n_steps=every_n_steps,
+      warm_steps=warm_steps, metric_logger=logger.get_benchmark_logger())
+
+
+def get_logging_metric_hook(tensors_to_log=None,
+                            every_n_secs=600,
+                            **kwargs):  # pylint: disable=unused-argument
+  """Function to get LoggingMetricHook.
+
+  Args:
+    tensors_to_log: List of tensor names or dictionary mapping labels to tensor
+      names. If not set, log _TENSORS_TO_LOG by default.
+    every_n_secs: `int`, the frequency for logging the metric. Default to every
+      10 mins.
+    **kwargs: a dictionary of arguments.
+
+  Returns:
+    Returns a LoggingMetricHook that saves tensor values in a JSON format.
+  """
+  if tensors_to_log is None:
+    tensors_to_log = _TENSORS_TO_LOG
+  return metric_hook.LoggingMetricHook(
+      tensors=tensors_to_log,
+      metric_logger=logger.get_benchmark_logger(),
+      every_n_secs=every_n_secs)
+
+
+def get_step_counter_hook(**kwargs):
+  """Function to get StepCounterHook."""
+  del kwargs
+  return tf.estimator.StepCounterHook()
+
+
+# A dictionary to map one hook name and its corresponding function
+HOOKS = {
+    'loggingtensorhook': get_logging_tensor_hook,
+    'profilerhook': get_profiler_hook,
+    'examplespersecondhook': get_examples_per_second_hook,
+    'loggingmetrichook': get_logging_metric_hook,
+    'stepcounterhook': get_step_counter_hook
+}

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/implementations/TensorFlow/utils/logs/logger.py

@@ -0,0 +1,423 @@
+# Copyright 2018 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.
+# ==============================================================================
+
+"""Logging utilities for benchmark.
+
+For collecting local environment metrics like CPU and memory, certain python
+packages need be installed. See README for details.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import contextlib
+import datetime
+import json
+import multiprocessing
+import numbers
+import os
+import threading
+import uuid
+
+from six.moves import _thread as thread
+from absl import flags
+import tensorflow as tf
+from tensorflow.python.client import device_lib
+
+from TensorFlow.utils.logs import cloud_lib
+
+METRIC_LOG_FILE_NAME = "metric.log"
+BENCHMARK_RUN_LOG_FILE_NAME = "benchmark_run.log"
+_DATE_TIME_FORMAT_PATTERN = "%Y-%m-%dT%H:%M:%S.%fZ"
+GCP_TEST_ENV = "GCP"
+RUN_STATUS_SUCCESS = "success"
+RUN_STATUS_FAILURE = "failure"
+RUN_STATUS_RUNNING = "running"
+
+
+FLAGS = flags.FLAGS
+
+# Don't use it directly. Use get_benchmark_logger to access a logger.
+_benchmark_logger = None
+_logger_lock = threading.Lock()
+
+
+def config_benchmark_logger(flag_obj=None):
+  """Config the global benchmark logger."""
+  _logger_lock.acquire()
+  try:
+    global _benchmark_logger
+    if not flag_obj:
+      flag_obj = FLAGS
+
+    if (not hasattr(flag_obj, "benchmark_logger_type") or
+        flag_obj.benchmark_logger_type == "BaseBenchmarkLogger"):
+      _benchmark_logger = BaseBenchmarkLogger()
+    elif flag_obj.benchmark_logger_type == "BenchmarkFileLogger":
+      _benchmark_logger = BenchmarkFileLogger(flag_obj.benchmark_log_dir)
+    elif flag_obj.benchmark_logger_type == "BenchmarkBigQueryLogger":
+      from benchmark import benchmark_uploader as bu  # pylint: disable=g-import-not-at-top
+      bq_uploader = bu.BigQueryUploader(gcp_project=flag_obj.gcp_project)
+      _benchmark_logger = BenchmarkBigQueryLogger(
+          bigquery_uploader=bq_uploader,
+          bigquery_data_set=flag_obj.bigquery_data_set,
+          bigquery_run_table=flag_obj.bigquery_run_table,
+          bigquery_run_status_table=flag_obj.bigquery_run_status_table,
+          bigquery_metric_table=flag_obj.bigquery_metric_table,
+          run_id=str(uuid.uuid4()))
+    else:
+      raise ValueError("Unrecognized benchmark_logger_type: %s"
+                       % flag_obj.benchmark_logger_type)
+
+  finally:
+    _logger_lock.release()
+  return _benchmark_logger
+
+
+def get_benchmark_logger():
+  if not _benchmark_logger:
+    config_benchmark_logger()
+  return _benchmark_logger
+
+
+@contextlib.contextmanager
+def benchmark_context(flag_obj):
+  """Context of benchmark, which will update status of the run accordingly."""
+  benchmark_logger = config_benchmark_logger(flag_obj)
+  try:
+    yield
+    benchmark_logger.on_finish(RUN_STATUS_SUCCESS)
+  except Exception:  # pylint: disable=broad-except
+    # Catch all the exception, update the run status to be failure, and re-raise
+    benchmark_logger.on_finish(RUN_STATUS_FAILURE)
+    raise
+
+
+class BaseBenchmarkLogger(object):
+  """Class to log the benchmark information to STDOUT."""
+
+  def log_evaluation_result(self, eval_results):
+    """Log the evaluation result.
+
+    The evaluate result is a dictionary that contains metrics defined in
+    model_fn. It also contains a entry for global_step which contains the value
+    of the global step when evaluation was performed.
+
+    Args:
+      eval_results: dict, the result of evaluate.
+    """
+    if not isinstance(eval_results, dict):
+      tf.compat.v1.logging.warning(
+          "eval_results should be dictionary for logging. Got %s",
+          type(eval_results))
+      return
+    global_step = eval_results[tf.compat.v1.GraphKeys.GLOBAL_STEP]
+    for key in sorted(eval_results):
+      if key != tf.compat.v1.GraphKeys.GLOBAL_STEP:
+        self.log_metric(key, eval_results[key], global_step=global_step)
+
+  def log_metric(self, name, value, unit=None, global_step=None, extras=None):
+    """Log the benchmark metric information to local file.
+
+    Currently the logging is done in a synchronized way. This should be updated
+    to log asynchronously.
+
+    Args:
+      name: string, the name of the metric to log.
+      value: number, the value of the metric. The value will not be logged if it
+        is not a number type.
+      unit: string, the unit of the metric, E.g "image per second".
+      global_step: int, the global_step when the metric is logged.
+      extras: map of string:string, the extra information about the metric.
+    """
+    metric = _process_metric_to_json(name, value, unit, global_step, extras)
+    if metric:
+      tf.compat.v1.logging.info("Benchmark metric: %s", metric)
+
+  def log_run_info(self, model_name, dataset_name, run_params, test_id=None):
+    tf.compat.v1.logging.info(
+        "Benchmark run: %s", _gather_run_info(model_name, dataset_name,
+                                              run_params, test_id))
+
+  def on_finish(self, status):
+    pass
+
+
+class BenchmarkFileLogger(BaseBenchmarkLogger):
+  """Class to log the benchmark information to local disk."""
+
+  def __init__(self, logging_dir):
+    super(BenchmarkFileLogger, self).__init__()
+    self._logging_dir = logging_dir
+    if not tf.io.gfile.isdir(self._logging_dir):
+      tf.io.gfile.makedirs(self._logging_dir)
+    self._metric_file_handler = tf.io.gfile.GFile(
+        os.path.join(self._logging_dir, METRIC_LOG_FILE_NAME), "a")
+
+  def log_metric(self, name, value, unit=None, global_step=None, extras=None):
+    """Log the benchmark metric information to local file.
+
+    Currently the logging is done in a synchronized way. This should be updated
+    to log asynchronously.
+
+    Args:
+      name: string, the name of the metric to log.
+      value: number, the value of the metric. The value will not be logged if it
+        is not a number type.
+      unit: string, the unit of the metric, E.g "image per second".
+      global_step: int, the global_step when the metric is logged.
+      extras: map of string:string, the extra information about the metric.
+    """
+    metric = _process_metric_to_json(name, value, unit, global_step, extras)
+    if metric:
+      try:
+        json.dump(metric, self._metric_file_handler)
+        self._metric_file_handler.write("\n")
+        self._metric_file_handler.flush()
+      except (TypeError, ValueError) as e:
+        tf.compat.v1.logging.warning(
+            "Failed to dump metric to log file: name %s, value %s, error %s",
+            name, value, e)
+
+  def log_run_info(self, model_name, dataset_name, run_params, test_id=None):
+    """Collect most of the TF runtime information for the local env.
+
+    The schema of the run info follows official/benchmark/datastore/schema.
+
+    Args:
+      model_name: string, the name of the model.
+      dataset_name: string, the name of dataset for training and evaluation.
+      run_params: dict, the dictionary of parameters for the run, it could
+        include hyperparameters or other params that are important for the run.
+      test_id: string, the unique name of the test run by the combination of key
+        parameters, eg batch size, num of GPU. It is hardware independent.
+    """
+    run_info = _gather_run_info(model_name, dataset_name, run_params, test_id)
+
+    with tf.io.gfile.GFile(os.path.join(
+        self._logging_dir, BENCHMARK_RUN_LOG_FILE_NAME), "w") as f:
+      try:
+        json.dump(run_info, f)
+        f.write("\n")
+      except (TypeError, ValueError) as e:
+        tf.compat.v1.logging.warning(
+            "Failed to dump benchmark run info to log file: %s", e)
+
+  def on_finish(self, status):
+    self._metric_file_handler.flush()
+    self._metric_file_handler.close()
+
+
+class BenchmarkBigQueryLogger(BaseBenchmarkLogger):
+  """Class to log the benchmark information to BigQuery data store."""
+
+  def __init__(self,
+               bigquery_uploader,
+               bigquery_data_set,
+               bigquery_run_table,
+               bigquery_run_status_table,
+               bigquery_metric_table,
+               run_id):
+    super(BenchmarkBigQueryLogger, self).__init__()
+    self._bigquery_uploader = bigquery_uploader
+    self._bigquery_data_set = bigquery_data_set
+    self._bigquery_run_table = bigquery_run_table
+    self._bigquery_run_status_table = bigquery_run_status_table
+    self._bigquery_metric_table = bigquery_metric_table
+    self._run_id = run_id
+
+  def log_metric(self, name, value, unit=None, global_step=None, extras=None):
+    """Log the benchmark metric information to bigquery.
+
+    Args:
+      name: string, the name of the metric to log.
+      value: number, the value of the metric. The value will not be logged if it
+        is not a number type.
+      unit: string, the unit of the metric, E.g "image per second".
+      global_step: int, the global_step when the metric is logged.
+      extras: map of string:string, the extra information about the metric.
+    """
+    metric = _process_metric_to_json(name, value, unit, global_step, extras)
+    if metric:
+      # Starting new thread for bigquery upload in case it might take long time
+      # and impact the benchmark and performance measurement. Starting a new
+      # thread might have potential performance impact for model that run on
+      # CPU.
+      thread.start_new_thread(
+          self._bigquery_uploader.upload_benchmark_metric_json,
+          (self._bigquery_data_set,
+           self._bigquery_metric_table,
+           self._run_id,
+           [metric]))
+
+  def log_run_info(self, model_name, dataset_name, run_params, test_id=None):
+    """Collect most of the TF runtime information for the local env.
+
+    The schema of the run info follows official/benchmark/datastore/schema.
+
+    Args:
+      model_name: string, the name of the model.
+      dataset_name: string, the name of dataset for training and evaluation.
+      run_params: dict, the dictionary of parameters for the run, it could
+        include hyperparameters or other params that are important for the run.
+      test_id: string, the unique name of the test run by the combination of key
+        parameters, eg batch size, num of GPU. It is hardware independent.
+    """
+    run_info = _gather_run_info(model_name, dataset_name, run_params, test_id)
+    # Starting new thread for bigquery upload in case it might take long time
+    # and impact the benchmark and performance measurement. Starting a new
+    # thread might have potential performance impact for model that run on CPU.
+    thread.start_new_thread(
+        self._bigquery_uploader.upload_benchmark_run_json,
+        (self._bigquery_data_set,
+         self._bigquery_run_table,
+         self._run_id,
+         run_info))
+    thread.start_new_thread(
+        self._bigquery_uploader.insert_run_status,
+        (self._bigquery_data_set,
+         self._bigquery_run_status_table,
+         self._run_id,
+         RUN_STATUS_RUNNING))
+
+  def on_finish(self, status):
+    self._bigquery_uploader.update_run_status(
+        self._bigquery_data_set,
+        self._bigquery_run_status_table,
+        self._run_id,
+        status)
+
+
+def _gather_run_info(model_name, dataset_name, run_params, test_id):
+  """Collect the benchmark run information for the local environment."""
+  run_info = {
+      "model_name": model_name,
+      "dataset": {"name": dataset_name},
+      "machine_config": {},
+      "test_id": test_id,
+      "run_date": datetime.datetime.utcnow().strftime(
+          _DATE_TIME_FORMAT_PATTERN)}
+  _collect_tensorflow_info(run_info)
+  _collect_tensorflow_environment_variables(run_info)
+  _collect_run_params(run_info, run_params)
+  _collect_cpu_info(run_info)
+  _collect_memory_info(run_info)
+  _collect_test_environment(run_info)
+  return run_info
+
+
+def _process_metric_to_json(
+    name, value, unit=None, global_step=None, extras=None):
+  """Validate the metric data and generate JSON for insert."""
+  if not isinstance(value, numbers.Number):
+    tf.compat.v1.logging.warning(
+        "Metric value to log should be a number. Got %s", type(value))
+    return None
+
+  extras = _convert_to_json_dict(extras)
+  return {
+      "name": name,
+      "value": float(value),
+      "unit": unit,
+      "global_step": global_step,
+      "timestamp": datetime.datetime.utcnow().strftime(
+          _DATE_TIME_FORMAT_PATTERN),
+      "extras": extras}
+
+
+def _collect_tensorflow_info(run_info):
+  run_info["tensorflow_version"] = {
+      "version": tf.version.VERSION, "git_hash": tf.version.GIT_VERSION}
+
+
+def _collect_run_params(run_info, run_params):
+  """Log the parameter information for the benchmark run."""
+  def process_param(name, value):
+    type_check = {
+        str: {"name": name, "string_value": value},
+        int: {"name": name, "long_value": value},
+        bool: {"name": name, "bool_value": str(value)},
+        float: {"name": name, "float_value": value},
+    }
+    return type_check.get(type(value),
+                          {"name": name, "string_value": str(value)})
+  if run_params:
+    run_info["run_parameters"] = [
+        process_param(k, v) for k, v in sorted(run_params.items())]
+
+
+def _collect_tensorflow_environment_variables(run_info):
+  run_info["tensorflow_environment_variables"] = [
+      {"name": k, "value": v}
+      for k, v in sorted(os.environ.items()) if k.startswith("TF_")]
+
+
+# The following code is mirrored from tensorflow/tools/test/system_info_lib
+# which is not exposed for import.
+def _collect_cpu_info(run_info):
+  """Collect the CPU information for the local environment."""
+  cpu_info = {}
+
+  cpu_info["num_cores"] = multiprocessing.cpu_count()
+
+  try:
+    # Note: cpuinfo is not installed in the TensorFlow OSS tree.
+    # It is installable via pip.
+    import cpuinfo    # pylint: disable=g-import-not-at-top
+
+    info = cpuinfo.get_cpu_info()
+    cpu_info["cpu_info"] = info["brand"]
+    cpu_info["mhz_per_cpu"] = info["hz_advertised_raw"][0] / 1.0e6
+
+    run_info["machine_config"]["cpu_info"] = cpu_info
+  except ImportError:
+    tf.compat.v1.logging.warn(
+        "'cpuinfo' not imported. CPU info will not be logged.")
+
+
+def _collect_memory_info(run_info):
+  try:
+    # Note: psutil is not installed in the TensorFlow OSS tree.
+    # It is installable via pip.
+    import psutil   # pylint: disable=g-import-not-at-top
+    vmem = psutil.virtual_memory()
+    run_info["machine_config"]["memory_total"] = vmem.total
+    run_info["machine_config"]["memory_available"] = vmem.available
+  except ImportError:
+    tf.compat.v1.logging.warn(
+        "'psutil' not imported. Memory info will not be logged.")
+
+
+def _collect_test_environment(run_info):
+  """Detect the local environment, eg GCE, AWS or DGX, etc."""
+  if cloud_lib.on_gcp():
+    run_info["test_environment"] = GCP_TEST_ENV
+  # TODO(scottzhu): Add more testing env detection for other platform
+
+
+def _parse_gpu_model(physical_device_desc):
+  # Assume all the GPU connected are same model
+  for kv in physical_device_desc.split(","):
+    k, _, v = kv.partition(":")
+    if k.strip() == "name":
+      return v.strip()
+  return None
+
+
+def _convert_to_json_dict(input_dict):
+  if input_dict:
+    return [{"name": k, "value": v} for k, v in sorted(input_dict.items())]
+  else:
+    return []

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/scripts/launch_keras_resnet_hvd.sh

@@ -0,0 +1,618 @@
+#!/bin/bash
+
+DEBUG=${DEBUG:-0}
+if [[ $DEBUG -eq 1 ]]; then
+    set -x
+    env
+fi
+
+# Basic paths
+SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+export BASE_PATH="$( cd "$(dirname "$(readlink -e ${SCRIPT_DIR}/TensorFlow)" )" && pwd)"
+
+PYTHONPATH=${BASE_PATH}:$PYTHONPATH
+IMAGENET_DIR=/root/datasets/imagenet/tf_records
+exit_code=0
+
+# Determine OpenMPI prefix from location of mpirun in the system
+OMPI_PREFIX=$(which mpirun)
+if [[ ! -z $OMPI_PREFIX ]]; then
+    OMPI_PREFIX=$(dirname $(dirname ${OMPI_PREFIX}) )
+fi
+
+# Fixed variables needed by this script
+export NUM_WORKERS_PER_HLS=${NUM_WORKERS_PER_HLS:-4}
+export HLS_TYPE=${HLS_TYPE:-HLS2}
+
+function help()
+{
+    echo  "Usage:"
+    echo  "$0 [ -key1 value1 -key2 value2  .... -keyn valuen ]"
+    echo  "-b      | --batch-size       Batch size"
+    echo  "-c      | --config           Configuration file path (defaults to ./defaults.cfg)"
+    echo  "-p      | --cpu-pin          [ none | cpu | numa ]"
+    echo  "-a      | --data-dir         Imagenet data directory"
+    echo  "-m      | --model-dir        Model dir, defaults to /tmp/resnet_50"
+    echo  "-dc     | --dataset_cache    Enable (true) or disable (false) dataset caching"
+    echo  "-noEval | --disable_eval     Enable (0) or disable (1) evaluation"
+    echo  "-bf16   | --enable_bf16"
+    echo  "-mlperf | --enable_mlperf"
+    echo  "-e      | --epochs           Number of epochs"
+    echo  "-ebe    | --epochs_between_eval  Number of training epochs between eval"
+    echo  "-eof    | --epoch_eval_offset"
+    echo  "-hf     | --hostfile		Host file path, 'localhost' is used if no file is provided"
+    echo  "-lbs    | --label_smoothing"
+    echo  "-l      | --lars-opt         Enable LARS optimizer"
+    echo  "-lde    | --lars_decay_epochs"
+    echo  "-mm     | --momentum"
+    echo  "-md     | --modeling		Enable (1) or disable (0) TF dumpos for SPARTA modeling"
+    echo  "-w      | --number-worker    Number of Gaudis"
+    echo  "-rs     | --resnet-size      Resnet size"
+    echo  "-slr    | --start_learning_rate"
+    echo  "-sth    | --stop_thold       Target accuracy"
+    echo  "-s      | --steps            Display logs for evey number of steps"
+    echo  "-sl     | --steps-per-loop   Number of steps per loop in Keras implementation"
+    echo  "-sd     | --synthetic_data   Enable (1) or disable (0) synthetic dataset"
+    echo  "-tev    | --train_eval"
+    echo  "-ts     | --train_steps      Train steps, will be overwritten if epochs > 0"
+    echo  "-u      | --use_horovod      Enable (1) or disable (0) horovod use"
+    echo  "-we     | --warmup_epochs"
+    echo  "-wd     | --weight_decay"
+    echo  "-nas    | --num_accumulation_steps"
+    echo  "-crc    | --clean_recipe_cache Clean TF recipe cache Enable (1) disable (0), default: 1"
+    echo  "-tcp    | --mpi_tcp_include"
+    echo  "-log    | --log_dir"
+    echo  "-ps     | --pod_size"
+    echo  "-ntf    | --num_train_files  Number of training tf records"
+    echo  "-nef    | --num_eval_files   Number of evaluation tf records"
+    echo  "-sfg    | --signaling_from_graph Enable (1) or disable (0) signaling from graph, default is 1"
+}
+
+function getmulti_hls_ips()
+{
+    if [[ $USE_HOROVOD -ne 1 ]]; then
+        return
+    fi
+
+    multi_hcl_ip="MULTI_HLS_IPS="
+    hostsFile=$1
+    firstHost=1
+    hostCount=0
+
+    # iterate over non-empty and non-commented lines
+    for h in $(cat $hostsFile | sed '/^$/d' | grep -v '^#'); do
+        if [[ $firstHost -eq 1 ]]; then
+            firstHost=0
+        else
+            multi_hcl_ip+=","
+        fi
+        multi_hcl_ip+=$h
+        hostCount=$((hostCount + 1))
+    done
+
+    echo "[getmulti_hls_ips] Host Count : $hostCount"
+    echo "[getmulti_hls_ips] Exporting  : $multi_hcl_ip"
+    export $multi_hcl_ip
+}
+
+function generate_mpi_hostfile()
+{
+    if [[ $USE_HOROVOD -ne 1 ]]; then
+        return
+    fi
+
+    echo "Generating MPI hostfile..."
+    local num_nodes=${2:-8}
+    local file_name="hostfile"
+    export MPI_HOSTFILE_PATH=$1/${file_name}
+
+    rm -rf ${MPI_HOSTFILE_PATH}
+    echo "PATH: ${MPI_HOSTFILE_PATH}"
+    touch ${MPI_HOSTFILE_PATH}
+
+    IFS=',' read -ra IPS <<< "$MULTI_HLS_IPS"
+    for i in "${IPS[@]}"; do
+        echo "$i slots=${num_nodes}" >> ${MPI_HOSTFILE_PATH}
+    done
+
+    echo "Config: "
+    cat ${MPI_HOSTFILE_PATH}
+}
+
+function run_per_ip()
+{
+    if [[ $USE_HOROVOD -ne 1 ]]; then
+        _cmd="$@"
+        $_cmd
+        return 0
+    fi
+
+    if [ -n "$OMPI_COMM_WORLD_SIZE" ]; then
+        print_error "Function run_per_ip is not meant to be ran from within an OpenMPI context. It is intended to invoke mpirun by itelf."
+        exit 1
+    fi
+
+    _cmd="$@"
+
+    if [[ -z ${MULTI_HLS_IPS} ]]; then
+        echo "[launch_keras_resnet_hvd] MULTI_HLS_IPS undefined - maybe a missing /root/shared/hosts file?"
+        exit -1
+    else
+        if [ -n "$MPI_TCP_INCLUDE" ]; then
+            _option_btl_tcp_if_include="--mca btl_tcp_if_include ${MPI_TCP_INCLUDE}"
+        else
+            _option_btl_tcp_if_include=""
+        fi
+
+        mpirun --allow-run-as-root \
+            --mca plm_rsh_args -p${SSH_PORT} \
+            ${_option_btl_tcp_if_include} \
+            --tag-output \
+            --merge-stderr-to-stdout \
+            --prefix ${OMPI_PREFIX} \
+            -H ${MULTI_HLS_IPS} \
+            bash -c "`declare`; `declare -x`; ($_cmd 2>&1)" 2>/dev/null
+    fi
+}
+
+# Parse command line options
+unset __bsize
+unset __config
+unset __data_dir
+unset __jpeg_data_dir
+unset __dataset_cache
+unset __disable_eval
+unset __enable_bf16_conversion
+unset __enable_lars
+unset __enable_mlperf
+unset __epochs
+unset __epochs_between_eval
+unset __eval_offset_epochs
+unset __hostfile
+unset __label_smoothing
+unset __lars_decay_epochs
+unset __momentum
+unset __modeling
+unset __number_Worker
+unset __resnetSize
+unset __run_number
+unset __start_learning_rate
+unset __steps
+unset __steps_per_loop
+unset __stop_thold
+unset __train_eval
+unset __train_steps
+unset __use_horovod
+unset __synthetic_data
+unset __warmup_epochs
+unset __weight_decay
+unset __num_accumulation_steps
+unset __workload_to_cpu_pin_type
+unset __dataset_cache
+unset __clean_recipe_cache
+unset __mpi_tcp_include
+unset __log_dir
+unset __model_dir
+unset __pod_size
+unset __num_train_files
+unset __num_eval_files
+unset __ssh_port
+unset __signaling_from_graph
+
+while [ -n "$1" ]; do
+    case $1 in
+        -rs | --resnet-size )
+            shift
+            __resnetSize=$1
+            ;;
+        -c | --config )
+            shift
+            __config=$1
+            ;;
+        -a | --data-dir )
+            shift
+            __data_dir=$1
+            ;;
+        -ja | --jpeg-data-dir )
+            shift
+            __jpeg_data_dir=$1
+            ;;
+        -m | --model-dir )
+            shift
+            __model_dir=$1
+            ;;
+        -b | --batch-size )
+            shift
+            __bsize=$1
+            ;;
+        -s | --steps )
+            shift
+            __steps=$1
+            ;;
+        -sl | --steps-per-loop )
+            shift
+            __steps_per_loop=$1
+            ;;
+        -e | --epochs )
+            shift
+            __epochs=$1
+            ;;
+        -w | --number-worker )
+            shift
+            __number_Worker=$1
+            ;;
+        -hf | --hostfile)
+            shift
+            __hostfile=$1
+            ;;
+        -l | --lars-opt)
+            shift
+            __enable_lars=$1
+            ;;
+        -dc | --dataset_cache)
+            shift
+            __dataset_cache=$1
+            ;;
+        -ebe | --epochs_between_eval)
+            shift
+            __epochs_between_eval=$1
+            ;;
+	    -ts | --train_steps)
+            shift
+            __train_steps=$1
+            ;;
+        -we | --warmup_epochs)
+            shift
+            __warmup_epochs=$1
+            ;;
+        -wd | --weight_decay)
+            shift
+            __weight_decay=$1
+            ;;
+        -nas | --num_accumulation_steps)
+            shift
+            __num_accumulation_steps=$1
+            ;;
+        -lbs | --label_smoothing)
+            shift
+            __label_smoothing=$1
+            ;;
+        -slr | --start_learning_rate)
+            shift
+            __start_learning_rate=$1
+            ;;
+        -sd  | --synthetic_data)
+            shift
+            __synthetic_data=$1
+            ;;
+        -mlperf | --enable_mlperf)
+            shift
+            __enable_mlperf=$1
+            ;;
+        -noEval | --disable_eval)
+            shift
+            __disable_eval=$1
+            ;;
+        -tev | --train_eval)
+            shift
+            __train_eval=$1
+            ;;
+        -bf16 | --enable_bf16)
+            shift
+            __enable_bf16_conversion=$1
+            ;;
+        -eof | --epoch_eval_offset)
+            shift
+            __eval_offset_epochs=$1
+            ;;
+        -sth | --stop_thold)
+            shift
+            __stop_thold=$1
+            ;;
+        -mm | --momentum)
+            shift
+            __momentum=$1
+            ;;
+        -md | --modeling)
+            shift
+            __modeling=$1
+            ;;
+        -rn | --run-number )
+            shift
+            __run_number=$1
+            ;;
+        -p | --cpu-pin)
+            shift
+            __workload_to_cpu_pin_type=$1
+            case ${__workload_to_cpu_pin_type} in
+                numa | cpu | none )
+                         ;;
+                *)
+                echo "--cpu-pin must be one of the following numa | cpu | none "
+                exit 1
+            esac
+            ;;
+        -u | --use_horovod)
+            shift
+            __use_horovod=$1
+            ;;
+        -dc | --dataset_cache)
+            shift
+            __dataset_cache=$1
+            ;;
+        -lde | --lars_decay_epochs)
+            shift
+            __lars_decay_epochs=$1
+            ;;
+        -crc | --clean_recipe_cache)
+                shift
+            __clean_recipe_cache=$1
+            ;;
+        -tcp | --mpi_tcp_include)
+            shift
+            __mpi_tcp_include=$1
+            ;;
+        -log | --log_dir)
+            shift
+            __log_dir=$1
+            ;;
+        -ps  | --pod_size)
+            shift
+            __pod_size=$1
+            ;;
+        -ntf | --num_train_files)
+            shift
+            __num_train_files=$1
+            ;;
+        -nef | --num_eval_files)
+            shift
+            __num_eval_files=$1
+            ;;
+        -port | --ssh_port)
+            shift
+            __ssh_port=$1
+            ;;
+        -sfg | --signaling_from_graph)
+            shift
+            __signaling_from_graph=$1
+            ;;
+        -h | --help)
+            help
+	    exit 1
+            ;;
+            * )
+            echo "The parameter $1 is not allowed"
+            help
+            ;;
+    esac
+    shift
+done
+
+# Set default values for environmental variable
+export CFG_FILE=${__config:-"${BASE_PATH}/defaults.cfg"}
+export HOST_FILE=${__hostfile:-"${OMPI_MCA_orte_default_hostfile}"}
+export SSH_PORT=${__ssh_port:-"3022"}
+
+if [[ -f ${CFG_FILE} ]]; then
+        source ${CFG_FILE}
+else
+        echo "Could not find ${CFG_FILE}"
+        exit 1
+fi
+
+# Set default directory name
+WORK_DIR=/tmp/resnet50
+
+# set default LOG_DIR
+export testdate=`date +%Y-%m-%d`
+export testtime=`date +%H%M%S`
+export LOG_DIR=/root/scratch/resnet/resnet_gaudi${NUM_WORKERS}_${testdate}_${testtime}
+
+# Override defaults with command line options if needed
+export RESNET_SIZE=${__resnetSize:-"$RESNET_SIZE"}
+export IMAGENET_DIR=${__data_dir:-"$IMAGENET_DIR"}
+export JPEG_IMAGENET_DIR=${__jpeg_data_dir:-"$JPEG_IMAGENET_DIR"}
+export BATCH_SIZE=${__bsize:-"$BATCH_SIZE"}
+export TRAIN_EPOCHS=${__epochs:-"$TRAIN_EPOCHS"}
+export TRAIN_STEPS=${__train_steps:-"$TRAIN_STEPS"}
+export DISPLAY_STEPS=${__steps:-"$DISPLAY_STEPS"}
+export STEPS_PER_LOOP=${__steps_per_loop:-"$STEPS_PER_LOOP"}
+export NUM_WORKERS=${__number_Worker:-"$NUM_WORKERS"}
+export USE_LARS_OPTIMIZER=${__enable_lars:-"$USE_LARS_OPTIMIZER"}
+export CPU_BIND_TYPE=${__workload_to_cpu_pin_type:-"$CPU_BIND_TYPE"}
+export EPOCHS_BETWEEN_EVALS=${__epochs_between_eval:-"$EPOCHS_BETWEEN_EVALS"}
+export WEIGHT_DECAY=${__weight_decay:-"$WEIGHT_DECAY"}
+export NUM_ACCUMULATION_STEPS=${__num_accumulation_steps:-"$NUM_ACCUMULATION_STEPS"}
+export LABEL_SMOOTH=${__label_smoothing:-"$LABEL_SMOOTH"}
+export BASE_LEARNING_RATE=${__start_learning_rate:-"$BASE_LEARNING_RATE"}
+export WARMUP_EPOCHS=${__warmup_epochs:-"$WARMUP_EPOCHS"}
+export USE_MLPERF=${__enable_mlperf:-"$USE_MLPERF"}
+export NO_EVAL=${__disable_eval:-"$NO_EVAL"}
+export STOP_THRESHOLD=${__stop_thold:-"$STOP_THRESHOLD"}
+export LR_MOMENTUM=${__momentum:-"$LR_MOMENTUM"}
+export EVAL_OFFSET_EPOCHS=${__eval_offset_epochs:-"$EVAL_OFFSET_EPOCHS"}
+export TF_BF16_CONVERSION=${__enable_bf16_conversion:-"$TF_BF16_CONVERSION"}
+export USE_HOROVOD=${__use_horovod:-"$USE_HOROVOD"}
+export DATASET_CACHE=${__dataset_cache:-"$DATASET_CACHE"}
+export LARS_DECAY_EPOCHS=${__lars_decay_epochs:-"$LARS_DECAY_EPOCHS"}
+export SYNTHETIC_DATA=${__synthetic_data:-"$SYNTHETIC_DATA"}
+if [ -z ${__train_eval} ]; then
+    export TRAIN_AND_EVAL=${__train_eval:-"$TRAIN_AND_EVAL"}
+fi
+export TRAIN_STEPS=${TRAIN_STEPS:--1}
+export MODELING=${__modeling:-"$MODELING"}
+export CLEAN_RECIPE_CACHE=${__clean_recipe_cache:-1}
+export MPI_TCP_INCLUDE=${__mpi_tcp_include:-$MPI_TCP_INCLUDE}
+export LOG_DIR=${__log_dir:-"$LOG_DIR"}
+export WORK_DIR=${__model_dir:-"$WORK_DIR"}
+export NUM_TRAIN_FILES=${__num_train_files:-"$NUM_TRAIN_FILES"}
+export NUM_EVAL_FILES=${__num_eval_files:-"$NUM_EVAL_FILES"}
+# Workaound on SW-75839
+export TF_ENABLE_DYNAMIC_SHAPES=${TF_ENABLE_DYNAMIC_SHAPES:-false}
+export SIGNALING_FROM_GRAPH=${__signaling_from_graph:-1}
+
+echo "[launch_keras_resnet_hvd] General Settings:"
+echo "[launch_keras_resnet_hvd] CFG_FILE"  $CFG_FILE
+echo "[launch_keras_resnet_hvd] HOST_FILE"  $HOST_FILE
+echo "[launch_keras_resnet_hvd] NUM_WORKERS"  $NUM_WORKERS
+echo "[launch_keras_resnet_hvd] RESNET_SIZE" $RESNET_SIZE
+echo "[launch_keras_resnet_hvd] IMAGENET_DIR" $IMAGENET_DIR
+echo "[launch_keras_resnet_hvd] JPEG_IMAGENET_DIR" $JPEG_IMAGENET_DIR
+echo "[launch_keras_resnet_hvd] BATCH_SIZE"  $BATCH_SIZE
+echo "[launch_keras_resnet_hvd] TRAIN_EPOCHS" $TRAIN_EPOCHS
+echo "[launch_keras_resnet_hvd] TRAIN_STEPS" $TRAIN_STEPS
+echo "[launch_keras_resnet_hvd] DISPLAY_STEPS" $DISPLAY_STEPS
+echo "[launch_keras_resnet_hvd] USE_LARS_OPTIMIZER" $USE_LARS_OPTIMIZER
+echo "[launch_keras_resnet_hvd] CPU_BIND_TYPE" $CPU_BIND_TYPE
+echo "[launch_keras_resnet_hvd] EPOCHS_BETWEEN_EVALS" $EPOCHS_BETWEEN_EVALS
+echo "[launch_keras_resnet_hvd] TRAIN_AND_EVAL" $TRAIN_AND_EVAL
+echo "[launch_keras_resnet_hvd] TF_BF16_CONVERSION" $TF_BF16_CONVERSION
+echo "[launch_keras_resnet_hvd] USE_HOROVOD" $USE_HOROVOD
+echo "[launch_keras_resnet_hvd] DATASET_CACHE" $DATASET_CACHE
+echo "[launch_keras_resnet_hvd] MODELING" $MODELING
+echo "[launch_keras_resnet_hvd] MPI_TCP_INCLUDE" $MPI_TCP_INCLUDE
+echo "[launch_keras_resnet_hvd] LOG_DIR" $LOG_DIR
+echo "[launch_keras_resnet_hvd] NUM_TRAIN_FILES" $NUM_TRAIN_FILES
+echo "[launch_keras_resnet_hvd] NUM_EVAL_FILES" $NUM_EVAL_FILES
+echo
+echo "[launch_keras_resnet_hvd] Learning Setting:"
+echo "[launch_keras_resnet_hvd] WEIGHT_DECAY" $WEIGHT_DECAY
+echo "[launch_keras_resnet_hvd] NUM_ACCUMULATION_STEPS" $NUM_ACCUMULATION_STEPS
+echo "[launch_keras_resnet_hvd] LABEL_SMOOTH" $LABEL_SMOOTH
+echo "[launch_keras_resnet_hvd] BASE_LEARNING_RATE" $BASE_LEARNING_RATE
+echo "[launch_keras_resnet_hvd] WARMUP_EPOCHS" $WARMUP_EPOCHS
+echo "[launch_keras_resnet_hvd] USE_MLPERF" $USE_MLPERF
+echo "[launch_keras_resnet_hvd] NO_EVAL" $NO_EVAL
+echo "[launch_keras_resnet_hvd] STOP_THRESHOLD" $STOP_THRESHOLD
+echo "[launch_keras_resnet_hvd] LR_MOMENTUM" $LR_MOMENTUM
+echo "[launch_keras_resnet_hvd] EVAL_OFFSET_EPOCHS" $EVAL_OFFSET_EPOCHS
+echo "[launch_keras_resnet_hvd] LARS_DECAY_EPOCHS" $LARS_DECAY_EPOCHS
+echo "[launch_keras_resnet_hvd] SYNTHETIC_DATA" $SYNTHETIC_DATA
+echo "[launch_keras_resnet_hvd] WORK_DIR" $WORK_DIR
+echo "[launch_keras_resnet_hvd] TF_ENABLE_DYNAMIC_SHAPES" $TF_ENABLE_DYNAMIC_SHAPES
+echo "[launch_keras_resnet_hvd] SIGNALING_FROM_GRAPH" $SIGNALING_FROM_GRAPH
+
+# This check always needs to go after all environment variable proccessing is complete.
+if [ ! -d ${IMAGENET_DIR} ] && [ ! -d ${JPEG_IMAGENET_DIR} ]; then
+    echo "[launch_keras_resnet_hvd] ImageNet image database not found on ${IMAGENET_DIR}"
+    exit -1
+fi
+
+rm -rf $LOG_DIR
+mkdir -p $WORK_DIR
+mkdir -p $LOG_DIR
+
+export MULTI_HLS_IPS=localhost
+if [[ -f ${HOST_FILE} ]]; then
+    getmulti_hls_ips ${HOST_FILE}
+fi
+
+# Setup the cahe directory and create ramdisk
+export TF_RECIPE_CACHE_PATH=${WORK_DIR}/graph_dump_recipes
+if [[ $CLEAN_RECIPE_CACHE -eq 1 ]]; then
+    run_per_ip rm -rf ${TF_RECIPE_CACHE_PATH}
+fi
+run_per_ip rm -rf ${WORK_DIR}/resnet_synth_data
+run_per_ip mkdir -p ${TF_RECIPE_CACHE_PATH}
+
+run_per_ip 'mkdir -p ${BASE_PATH}/log'
+
+printf "[launch_keras_resnet_hvd] Cleaning temp files...\n\n"
+run_per_ip rm -rf /tmp/checkpoint /tmp/eval /tmp/events.out.tfevents.* /tmp/graph.pbtxt /tmp/model.ckpt-*
+run_per_ip rm -rf /tmp/rank_*/checkpoint /tmp/rank_*/eval /tmp/rank_*/events.out.tfevents.* /tmp/rank_*/graph.pbtxt /tmp/rank_*/model.ckpt-*
+
+if [[ $USE_HOROVOD -eq 1 ]]; then
+
+    if [[  -z ${MULTI_HLS_IPS} ]]; then
+        echo "[launch_keras_resnet_hvd] MULTI_HLS_IPS undefined - maybe a missing /root/shared/hosts file?"
+        exit -1
+    fi
+
+    generate_mpi_hostfile ${WORK_DIR} ${NUM_WORKERS_PER_HLS}
+
+    # Substituted this by the calculation below
+    #calc_optimal_cpu_resources_for_mpi veces leri
+    MPI_MAP_BY=socket
+    MPI_MAP_BY_PE=`lscpu | grep "^CPU(s):"| awk -v NUM=${NUM_WORKERS_PER_HLS} '{print int($2/NUM/2)}'`
+    if [[ "$CPU_BIND_TYPE" == "numa" ||  "$CPU_BIND_TYPE" == "none" ]]; then
+        MPIRUN_ARGS_MAP_BY_PE="-bind-to none"
+    else
+        MPIRUN_ARGS_MAP_BY_PE="--bind-to core --map-by $MPI_MAP_BY:PE=$MPI_MAP_BY_PE"
+    fi
+
+    if [ -n "$MPI_TCP_INCLUDE" ]; then
+        _option_btl_tcp_if_include="--mca btl_tcp_if_include ${MPI_TCP_INCLUDE}"
+    else
+        _option_btl_tcp_if_include=""
+    fi
+
+    TRAINING_COMMAND="mpirun --allow-run-as-root \
+        -np $NUM_WORKERS --hostfile ${MPI_HOSTFILE_PATH} \
+        --prefix ${OMPI_PREFIX} \
+        --mca plm_rsh_args -p${SSH_PORT} \
+        ${_option_btl_tcp_if_include} \
+        -x BASE_PATH=${BASE_PATH} \
+        -x PYTHONPATH=${PYTHONPATH} \
+        -x DATASET_CACHE=${DATASET_CACHE} \
+        -x DEBUG=${DEBUG} \
+        -x RESNET_SIZE=${RESNET_SIZE} \
+        -x IMAGENET_DIR=${IMAGENET_DIR} \
+        -x JPEG_IMAGENET_DIR=${JPEG_IMAGENET_DIR} \
+        -x TF_BF16_CONVERSION=${TF_BF16_CONVERSION} \
+        -x TF_RECIPE_CACHE_PATH=${TF_RECIPE_CACHE_PATH} \
+        -x LD_PRELOAD=${LD_PRELOAD} \
+        -x TF_MODULES_RELEASE_BUILD=${TF_MODULES_RELEASE_BUILD} \
+        -x HABANA_LOGS=${HABANA_LOGS} \
+        -x CPU_BIND_TYPE=${CPU_BIND_TYPE} \
+        -x WORK_DIR=${WORK_DIR} \
+        -x BATCH_SIZE=${BATCH_SIZE} \
+        -x TRAIN_EPOCHS=${TRAIN_EPOCHS} \
+        -x TRAIN_STEPS=${TRAIN_STEPS} \
+        -x DISPLAY_STEPS=${DISPLAY_STEPS} \
+        -x STEPS_PER_LOOP=${STEPS_PER_LOOP} \
+        -x NUM_WORKERS=${NUM_WORKERS} \
+        -x EPOCHS_BETWEEN_EVALS=${EPOCHS_BETWEEN_EVALS} \
+        -x EVAL_OFFSET_EPOCHS=${EVAL_OFFSET_EPOCHS} \
+        -x WARMUP_EPOCHS=${WARMUP_EPOCHS} \
+        -x LABEL_SMOOTH=${LABEL_SMOOTH} \
+        -x WEIGHT_DECAY=${WEIGHT_DECAY} \
+        -x NUM_ACCUMULATION_STEPS=${NUM_ACCUMULATION_STEPS}
+        -x LR_MOMENTUM=${LR_MOMENTUM} \
+        -x USE_LARS_OPTIMIZER=${USE_LARS_OPTIMIZER} \
+        -x SYNTHETIC_DATA=${SYNTHETIC_DATA} \
+        -x BASE_LEARNING_RATE=${BASE_LEARNING_RATE} \
+        -x USE_MLPERF=${USE_MLPERF} \
+        -x ENABLE_BARRIERS=0 \
+        -x SCALE_OUT_PORTS=1 \
+        -x STOP_THRESHOLD=${STOP_THRESHOLD} \
+        -x NO_EVAL=${NO_EVAL} \
+        -x USE_HOROVOD=${USE_HOROVOD} \
+        -x TRAIN_STEPS=${TRAIN_STEPS} \
+        -x LARS_DECAY_EPOCHS=${LARS_DECAY_EPOCHS} \
+        -x LOG_DIR=${LOG_DIR} \
+        -x NUM_TRAIN_FILES=${NUM_TRAIN_FILES} \
+        -x NUM_EVAL_FILES=${NUM_EVAL_FILES} \
+        -x TF_ENABLE_DYNAMIC_SHAPES=${TF_ENABLE_DYNAMIC_SHAPES} \
+        ${MPIRUN_ARGS_MAP_BY_PE} \
+        -x MODELING=${MODELING} \
+        -x HOROVOD_FUSION_THRESHOLD \
+        -x SIGNALING_FROM_GRAPH \
+        --merge-stderr-to-stdout --output-filename ${LOG_DIR} \
+        ${SCRIPT_DIR}/run.sh"
+
+else
+    TRAINING_COMMAND="${SCRIPT_DIR}/run.sh"
+fi
+
+echo "TRAINING COMMAND = ${TRAINING_COMMAND}"
+printf "[launch_keras_resnet_hvd] Starting training...\n\n"
+$TRAINING_COMMAND
+
+run_per_ip rm -rf ${WORK_DIR}/resnet_synth_data
+
+rm -rf ${BASE_PATH}/log
+cp /root/build_log.csv ${LOG_DIR}/
+cp ${MPI_HOSTFILE_PATH} ${LOG_DIR}/
+cp -r ${LOG_DIR} ${BASE_PATH}/log
+chmod -R 777 ${LOG_DIR}
+exit $exit_code

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/scripts/run.sh

@@ -0,0 +1,168 @@
+#!/bin/bash
+
+if [[ $DEBUG -eq 1 ]]; then
+    set -x
+    env
+    #LOG_LEVEL:0 - TRACE, 1 - DEBUG, 2 - INFO, 3 - WARNING, 4 - ERROR, 5 - CRITICAL, 6 - OFF
+    export LOG_LEVEL_ALL_HCL=2
+else
+    export LOG_LEVEL_ALL_HCL=6
+fi
+
+if [ -z $BASE_PATH ]; then
+	BASE_PATH="$( cd "$(dirname "$(readlink -f ./defaults.cfg)" )" && pwd)"
+	PYTHONPATH=${BASE_PATH}:$PYTHONPATH
+fi
+
+TRAIN_SCRIPT=${BASE_PATH}/TensorFlow/computer_vision/Resnets/resnet_keras/resnet_ctl_imagenet_main.py
+PT_VERSION=`python3 -c 'import sys; print(f"{sys.version_info[0]}.{sys.version_info[1]}")'`
+TF_VERSION=`python3 -c "import tensorflow as tf; print(tf.__version__.replace('.', '_'))"`
+PATCH_PATH=/usr/local/lib/python${PT_VERSION}/dist-packages/habana_frameworks/tensorflow/tf${TF_VERSION}/lib/habanalabs
+# This is required for HW profiling but does not hurt so we add it always
+export PYTHONPATH=${PATCH_PATH}:${PYTHONPATH}
+
+# Fixed varaibles, not inherited from launcher
+export TF_ALLOW_CONTROL_EDGES_IN_HABANA_OPS=1
+export EXPERIMENTAL_PRELOADING=1
+export ENABLE_TENSORBOARD=false
+export REPORT_ACCURACY_METRICS=true
+export DIST_EVAL=true
+export ENABLE_DEVICE_WARMUP=true
+export TF_DISABLE_MKL=1
+export SYNTHETIC_DATA=${SYNTHETIC_DATA}
+
+if [[ $MODELING -eq 1 ]]; then
+    ENABLE_CHECKPOINT=true
+else
+    ENABLE_CHECKPOINT=false
+fi
+if [[ $TF_BF16_CONVERSION -eq 1 ]]; then
+    DATA_TYPE="bf16"
+else
+    DATA_TYPE="fp32"
+fi
+if [[  ${NO_EVAL} -eq 1 ]]; then
+    SKIP_EVAL=true
+else
+    SKIP_EVAL=false
+fi
+if [[ ${USE_LARS_OPTIMIZER} -eq 1 ]]; then
+	OPTIMIZER="LARS"
+else
+	OPTIMIZER="SGD"
+fi
+if [[ ${USE_HOROVOD} -eq 1 ]]; then
+	DIST_EVAL=true
+	USE_HOROVOD='--use_horovod'
+else
+	DIST_EVAL=false
+	USE_HOROVOD=''
+fi
+if [[ ${SYNTHETIC_DATA} -eq 1 ]]; then
+	SYNTHETIC_DATA=true
+fi
+if [[ -n ${NUM_ACCUMULATION_STEPS} ]]; then
+	NUM_ACCUMULATION_STEPS="--num_acc_steps=${NUM_ACCUMULATION_STEPS}"
+else
+	NUM_ACCUMULATION_STEPS=""
+fi
+
+if [[ -n ${JPEG_IMAGENET_DIR} ]]; then
+    JPEG_IMAGENET_DIR="--jpeg_data_dir=${JPEG_IMAGENET_DIR}"
+fi
+
+if [[ $SIGNALING_FROM_GRAPH -eq 1 ]]; then
+    export HOROVOD_FUSION_THRESHOLD=0
+    export TF_USE_SIGNALING_FROM_ENCAP_OP=1
+else
+    export TF_USE_SIGNALING_FROM_ENCAP_OP=0
+fi
+
+# clear cache
+PROC_FS=${PROC_FS:-"/proc"}
+sync && echo 3 > $PROC_FS/sys/vm/drop_caches
+
+TRAIN_COMMAND="python3 ${TRAIN_SCRIPT}
+    --model_dir=${WORK_DIR}
+    --data_dir=${IMAGENET_DIR}
+    ${JPEG_IMAGENET_DIR}
+    --batch_size=${BATCH_SIZE}
+    --distribution_strategy=off
+    --num_gpus=0
+    --data_format=channels_last
+    --train_epochs=${TRAIN_EPOCHS}
+    --train_steps=${TRAIN_STEPS}
+    --experimental_preloading=${EXPERIMENTAL_PRELOADING}
+    --log_steps=${DISPLAY_STEPS}
+    --steps_per_loop=${STEPS_PER_LOOP}
+    --enable_checkpoint_and_export=${ENABLE_CHECKPOINT}
+    --enable_tensorboard=${ENABLE_TENSORBOARD}
+    --epochs_between_evals=${EPOCHS_BETWEEN_EVALS}
+    --base_learning_rate=${BASE_LEARNING_RATE}
+    --warmup_epochs=${WARMUP_EPOCHS}
+    --optimizer=${OPTIMIZER}
+    --lr_schedule=polynomial
+    --label_smoothing=${LABEL_SMOOTH}
+    --weight_decay=${WEIGHT_DECAY}
+    $NUM_ACCUMULATION_STEPS
+    --single_l2_loss_op
+    ${USE_HOROVOD}
+    --modeling=${MODELING}
+    --data_loader_image_type=${DATA_TYPE}
+    --dtype=${DATA_TYPE}
+    --eval_offset_epochs=${EVAL_OFFSET_EPOCHS}
+    --report_accuracy_metrics=${REPORT_ACCURACY_METRICS}
+    --dist_eval=${DIST_EVAL}
+    --target_accuracy=${STOP_THRESHOLD}
+    --enable_device_warmup=${ENABLE_DEVICE_WARMUP}
+    --lars_decay_epochs=${LARS_DECAY_EPOCHS}
+    --momentum=${LR_MOMENTUM}
+    --skip_eval=${SKIP_EVAL}
+    --use_synthetic_data=${SYNTHETIC_DATA}
+    --dataset_cache=${DATASET_CACHE}
+    --num_train_files=${NUM_TRAIN_FILES}
+    --num_eval_files=${NUM_EVAL_FILES}
+"
+echo ${TRAIN_COMMAND}
+
+echo "[run] General Settings:"
+echo "[run] RESNET_SIZE" $RESNET_SIZE
+echo "[run] IMAGENET_DIR" $IMAGENET_DIR
+echo "[run] BATCH_SIZE"  $BATCH_SIZE
+echo "[run] NUM_WORKERS" $NUM_WORKERS
+echo "[run] TRAIN_EPOCHS" $TRAIN_EPOCHS
+echo "[run] TRAIN_STEPS" $TRAIN_STEPS
+echo "[run] DISPLAY_STEPS" $DISPLAY_STEPS
+echo "[run] USE_LARS_OPTIMIZER" $USE_LARS_OPTIMIZER
+echo "[run] CPU_BIND_TYPE" $CPU_BIND_TYPE
+echo "[run] EPOCHS_BETWEEN_EVALS" $EPOCHS_BETWEEN_EVALS
+echo "[run] TRAIN_AND_EVAL" $TRAIN_AND_EVAL
+echo "[run] TF_BF16_CONVERSION" $TF_BF16_CONVERSION
+echo "[run] DATASET_CACHE" $DATASET_CACHE
+echo "[run] USE_HOROVOD" $USE_HOROVOD
+echo
+echo "[run] Learning Setting:"
+echo "[run] WEIGHT_DECAY" $WEIGHT_DECAY
+echo "[run] NUM_ACCUMULATION_STEPS" $NUM_ACCUMULATION_STEPS
+echo "[run] LABEL_SMOOTH" $LABEL_SMOOTH
+echo "[run] BASE_LEARNING_RATE" $BASE_LEARNING_RATE
+echo "[run] WARMUP_EPOCHS" $WARMUP_EPOCHS
+echo "[run] USE_MLPERF" $USE_MLPERF
+echo "[run] NO_EVAL" $NO_EVAL
+echo "[run] STOP_THRESHOLD" $STOP_THRESHOLD
+echo "[run] LR_MOMENTUM" $LR_MOMENTUM
+echo "[run] EVAL_OFFSET_EPOCHS" $EVAL_OFFSET_EPOCHS
+echo "[run] LARS_DECAY_EPOCHS" $LARS_DECAY_EPOCHS
+echo "[run] SYNTHETIC_DATA" $SYNTHETIC_DATA
+
+if [[ ! -z $USE_HOROVOD ]] && [[ $CPU_BIND_TYPE == "numa" ]]; then
+	LOCAL_SNC_VALUE=$(( OMPI_COMM_WORLD_LOCAL_RANK ))
+	if [[ $HLS_TYPE == "HLS2" ]]; then
+		export NUMA_MAPPING_DIR=$BASE_PATH
+		bash list_affinity_topology_bare_metal.sh
+		CPU_RANGE=`cat $NUMA_MAPPING_DIR/.habana_moduleID$LOCAL_SNC_VALUE`
+	fi
+	LD_PRELOAD=${PRELOAD_PATH} numactl --physcpubind=${CPU_RANGE} ${TRAIN_COMMAND}
+else
+	LD_PRELOAD=${PRELOAD_PATH} ${TRAIN_COMMAND}
+fi

docker/bloom13b/Model-References/MLPERF3.1/Training/benchmarks/resnet/scripts/unpack_imagenet.sh

@@ -0,0 +1,164 @@
+#!/bin/bash
+###############################################################################
+# Copyright (c) 2023, Habana Labs Ltd.  All rights reserved.
+###############################################################################
+
+function print_synopsis()
+{
+    cat << HEREDOC
+
+    Usage: $program -ta|--train-archive PATH -va|--validation-archive PATH
+                    -o|--output-path PATH [-j|--jobs-number COUNT] [-h|--help]
+
+    Required arguments:
+        -ta, --train-archive PATH       path to ImageNet training archive
+        -va, --validation-archive PATH  path to ImageNet validation archive
+        -o, --output-path PATH          path to folder where ImageNet will be upacked
+
+    Optional arguments:
+        -j, --jobs-number COUNT          number of jobs used when unpacking training archive
+                                        default value is 16
+        -h, --help                      print this help message
+
+HEREDOC
+}
+
+function parse_args()
+{
+    export TRAIN_ARCHIVE_PATH=""
+    export VAL_ARCHIVE_PATH=""
+    export OUTPUT_PATH=""
+    export JOBS_NUMBER=16
+
+    while [ -n "$1" ]; do
+        case "$1" in
+            -ta | --train-archive )
+                export TRAIN_ARCHIVE_PATH=$2
+                shift 2
+                ;;
+            -va | --validation-archive )
+                export VAL_ARCHIVE_PATH=$2
+                shift 2
+                ;;
+            -o | --output-path )
+                export OUTPUT_PATH=$2
+                shift 2
+                ;;
+            -j | --jobs-number )
+                export JOBS_NUMBER=$2
+                shift 2
+                ;;
+            -h | --help )
+                print_synopsis
+                exit 0
+                ;;
+            * )
+                echo "error: invalid parameter: $1"
+                print_synopsis
+                exit 1
+                ;;
+        esac
+    done
+
+    if [[ ! -f "$TRAIN_ARCHIVE_PATH" ]]; then
+        echo "Please specify correct path to traing archive using -ta, --train-archive."
+        print_synopsis
+        exit 1
+    fi
+
+    if [[ ! -f "$VAL_ARCHIVE_PATH" ]]; then
+        echo "Please specify correct path to  validation archive using -va, --validation-archive."
+        print_synopsis
+        exit 1
+    fi
+
+    if [[ -z "$OUTPUT_PATH" ]]; then
+        echo "Please specify output path using -o, --output-path."
+        print_synopsis
+        exit 1
+    fi
+}
+
+function reset_folder()
+{
+    rm -rf $1
+    mkdir -p $1
+}
+
+function upack_train_subarchive()
+{
+    ARCHIVE_NAME=$1
+    ARCHIVE_INDEX=$2
+    NO_OF_ARCHIVES=$3
+    PRINT="$ARCHIVE_INDEX/$NO_OF_ARCHIVES: $ARCHIVE_NAME"
+    echo "Upacking $PRINT."
+
+    pushd $TRAIN_PATH > /dev/null
+
+    DIR=`basename $ARCHIVE_NAME .tar`
+    mkdir $DIR
+    tar xf $ARCHIVE_NAME -C $DIR
+    rm $ARCHIVE_NAME
+
+    popd > /dev/null
+    echo "Finished upacking $PRINT."
+}
+
+function unpack_train()
+{
+    export TRAIN_PATH="$OUTPUT_PATH/train"
+    export TMP_PATH="$OUTPUT_PATH/tmp"
+    reset_folder $TRAIN_PATH
+    reset_folder $TMP_PATH
+
+    echo "Unpacking training data."
+    tar xf $TRAIN_ARCHIVE_PATH -C $TMP_PATH
+
+    echo "Unpacking subarchives."
+    pushd $TMP_PATH > /dev/null
+    ARCHIVES_COUNT=$(ls *.tar | wc -l)
+    ARCHIVE_IDX=0
+    for ARCHIVE in *.tar; do
+        ((ARCHIVE_IDX++))
+
+        while : ; do
+            JOBS_COUNT=$(ls $TRAIN_PATH/*.tar 2> /dev/null | wc -l)
+            if [ "$JOBS_COUNT" -lt "$JOBS_NUMBER" ]; then
+                break
+            fi
+            sleep 1s
+        done
+
+        mv $ARCHIVE $TRAIN_PATH/
+        upack_train_subarchive $ARCHIVE $ARCHIVE_IDX $ARCHIVES_COUNT &
+    done
+    popd > /dev/null
+
+    wait
+    rm -rf $TMP_PATH
+    echo "Imagenet training data ready."
+}
+
+function unpack_val()
+{
+    export VAL_PATH="$OUTPUT_PATH/val"
+    reset_folder $VAL_PATH
+
+    echo "Unpacking validation data."
+    tar xf $VAL_ARCHIVE_PATH -C $VAL_PATH
+
+    echo "Reorganizing validation folder."
+    export VALPREP_ADDR=https://raw.githubusercontent.com/soumith/imagenetloader.torch/master/valprep.sh
+    pushd $VAL_PATH > /dev/null
+    wget -qO- $VALPREP_ADDR | bash
+    popd > /dev/null
+
+    echo "Imagenet validation data ready."
+}
+
+parse_args "$@"
+
+unpack_train &
+unpack_val &
+
+wait

docker/bloom13b/Model-References/MLPERF3.1/Training/systems/HLS-Gaudi2-N16-PT.json

@@ -0,0 +1,35 @@
+{
+  "submitter": "Intel-HabanaLabs",
+  "division": "closed",
+  "status": "available",
+  "system_name": "HLS-Gaudi2-N16-PT",
+  "number_of_nodes": "16",
+  "host_processors_per_node": "2",
+  "host_processor_model_name": "Intel(R) Xeon(R) Platinum 8380",
+  "host_processor_core_count": "40",
+  "host_processor_vcpu_count": "80",
+  "host_processor_frequency": "2.3 GHz",
+  "host_processor_caches": "L1d cache: 3.8 MiB, L1i cache: 2.5 MiB, L2 cache: 100 MiB, L3 cache: 120 MiB",
+  "host_processor_interconnect": "UPI",
+  "host_memory_capacity": "1024 GB",
+  "host_memory_configuration": "DDR4-3200",
+  "host_storage_type": "Weka",
+  "host_storage_capacity": "1 PB",
+  "host_networking": "2x Mellanox ConnectX-5 Ex 100Gb/s Ethernet",
+  "host_networking_topology": "L3 Fat Tree",
+  "accelerators_per_node": "8",
+  "accelerator_model_name": "Intel® Gaudi® 2 AI Accelerator",
+  "accelerator_host_interconnect": "4x PCIe 4.0 x16",
+  "accelerator_frequency": "1800MHz",
+  "accelerator_on-chip_memories": "6",
+  "accelerator_memory_configuration": "HBM2E",
+  "accelerator_memory_capacity": "96 GB",
+  "accelerator_interconnect": "24x 100Gb/s Ethernet",
+  "accelerator_interconnect_topology": "10x L3 Fat Tree",
+  "cooling": "Air-cooled",
+  "hw_notes": "",
+  "framework": "PyTorch 2.0.1a0",
+  "other_software_stack": "synapseAI 1.13.99",
+  "operating_system": "Ubuntu 20.04",
+  "sw_notes": ""
+}

docker/bloom13b/Model-References/MLPERF3.1/Training/systems/HLS-Gaudi2-N2-PT.json

@@ -0,0 +1,35 @@
+{
+  "submitter": "Intel-HabanaLabs",
+  "division": "closed",
+  "status": "available",
+  "system_name": "HLS-Gaudi2-N2-PT",
+  "number_of_nodes": "2",
+  "host_processors_per_node": "2",
+  "host_processor_model_name": "Intel(R) Xeon(R) Platinum 8380",
+  "host_processor_core_count": "40",
+  "host_processor_vcpu_count": "80",
+  "host_processor_frequency": "2.3 GHz",
+  "host_processor_caches": "L1d cache: 3.8 MiB, L1i cache: 2.5 MiB, L2 cache: 100 MiB, L3 cache: 120 MiB",
+  "host_processor_interconnect": "UPI",
+  "host_memory_capacity": "1024 GB",
+  "host_memory_configuration": "DDR4-3200",
+  "host_storage_type": "Weka",
+  "host_storage_capacity": "1 PB",
+  "host_networking": "2x Mellanox ConnectX-5 Ex 100Gb/s Ethernet",
+  "host_networking_topology": "L3 Fat Tree",
+  "accelerators_per_node": "8",
+  "accelerator_model_name": "Intel® Gaudi® 2 AI Accelerator",
+  "accelerator_host_interconnect": "4x PCIe 4.0 x16",
+  "accelerator_frequency": "1800MHz",
+  "accelerator_on-chip_memories": "6",
+  "accelerator_memory_configuration": "HBM2E",
+  "accelerator_memory_capacity": "96 GB",
+  "accelerator_interconnect": "24x 100Gb/s Ethernet",
+  "accelerator_interconnect_topology": "10x L3 Fat Tree",
+  "cooling": "Air-cooled",
+  "hw_notes": "",
+  "framework": "PyTorch 2.0.1a0",
+  "other_software_stack": "synapseAI 1.13.99",
+  "operating_system": "Ubuntu 20.04",
+  "sw_notes": ""
+}

docker/bloom13b/Model-References/MLPERF3.1/Training/systems/HLS-Gaudi2-N32-PT.json

@@ -0,0 +1,35 @@
+{
+  "submitter": "Intel-HabanaLabs",
+  "division": "closed",
+  "status": "available",
+  "system_name": "HLS-Gaudi2-N32-PT",
+  "number_of_nodes": "32",
+  "host_processors_per_node": "2",
+  "host_processor_model_name": "Intel(R) Xeon(R) Platinum 8380",
+  "host_processor_core_count": "40",
+  "host_processor_vcpu_count": "80",
+  "host_processor_frequency": "2.3 GHz",
+  "host_processor_caches": "L1d cache: 3.8 MiB, L1i cache: 2.5 MiB, L2 cache: 100 MiB, L3 cache: 120 MiB",
+  "host_processor_interconnect": "UPI",
+  "host_memory_capacity": "1024 GB",
+  "host_memory_configuration": "DDR4-3200",
+  "host_storage_type": "Weka",
+  "host_storage_capacity": "1 PB",
+  "host_networking": "2x Mellanox ConnectX-5 Ex 100Gb/s Ethernet",
+  "host_networking_topology": "L3 Fat Tree",
+  "accelerators_per_node": "8",
+  "accelerator_model_name": "Intel® Gaudi® 2 AI Accelerator",
+  "accelerator_host_interconnect": "4x PCIe 4.0 x16",
+  "accelerator_frequency": "1800MHz",
+  "accelerator_on-chip_memories": "6",
+  "accelerator_memory_configuration": "HBM2E",
+  "accelerator_memory_capacity": "96 GB",
+  "accelerator_interconnect": "24x 100Gb/s Ethernet",
+  "accelerator_interconnect_topology": "10x L3 Fat Tree",
+  "cooling": "Air-cooled",
+  "hw_notes": "",
+  "framework": "PyTorch 2.0.1a0",
+  "other_software_stack": "synapseAI 1.13.99",
+  "operating_system": "Ubuntu 20.04",
+  "sw_notes": ""
+}

docker/bloom13b/Model-References/MLPERF3.1/Training/systems/HLS-Gaudi2-N4-PT.json

@@ -0,0 +1,35 @@
+{
+  "submitter": "Intel-HabanaLabs",
+  "division": "closed",
+  "status": "available",
+  "system_name": "HLS-Gaudi2-N4-PT",
+  "number_of_nodes": "4",
+  "host_processors_per_node": "2",
+  "host_processor_model_name": "Intel(R) Xeon(R) Platinum 8380",
+  "host_processor_core_count": "40",
+  "host_processor_vcpu_count": "80",
+  "host_processor_frequency": "2.3 GHz",
+  "host_processor_caches": "L1d cache: 3.8 MiB, L1i cache: 2.5 MiB, L2 cache: 100 MiB, L3 cache: 120 MiB",
+  "host_processor_interconnect": "UPI",
+  "host_memory_capacity": "1024 GB",
+  "host_memory_configuration": "DDR4-3200",
+  "host_storage_type": "Weka",
+  "host_storage_capacity": "1 PB",
+  "host_networking": "2x Mellanox ConnectX-5 Ex 100Gb/s Ethernet",
+  "host_networking_topology": "L3 Fat Tree",
+  "accelerators_per_node": "8",
+  "accelerator_model_name": "Intel® Gaudi® 2 AI Accelerator",
+  "accelerator_host_interconnect": "4x PCIe 4.0 x16",
+  "accelerator_frequency": "1800MHz",
+  "accelerator_on-chip_memories": "6",
+  "accelerator_memory_configuration": "HBM2E",
+  "accelerator_memory_capacity": "96 GB",
+  "accelerator_interconnect": "24x 100Gb/s Ethernet",
+  "accelerator_interconnect_topology": "10x L3 Fat Tree",
+  "cooling": "Air-cooled",
+  "hw_notes": "",
+  "framework": "PyTorch 2.0.1a0",
+  "other_software_stack": "synapseAI 1.13.99",
+  "operating_system": "Ubuntu 20.04",
+  "sw_notes": ""
+}

docker/bloom13b/Model-References/MLPERF3.1/Training/systems/HLS-Gaudi2-N48-PT.json

@@ -0,0 +1,35 @@
+{
+  "submitter": "Intel-HabanaLabs",
+  "division": "closed",
+  "status": "available",
+  "system_name": "HLS-Gaudi2-N48-PT",
+  "number_of_nodes": "48",
+  "host_processors_per_node": "2",
+  "host_processor_model_name": "Intel(R) Xeon(R) Platinum 8380",
+  "host_processor_core_count": "40",
+  "host_processor_vcpu_count": "80",
+  "host_processor_frequency": "2.3 GHz",
+  "host_processor_caches": "L1d cache: 3.8 MiB, L1i cache: 2.5 MiB, L2 cache: 100 MiB, L3 cache: 120 MiB",
+  "host_processor_interconnect": "UPI",
+  "host_memory_capacity": "1024 GB",
+  "host_memory_configuration": "DDR4-3200",
+  "host_storage_type": "Weka",
+  "host_storage_capacity": "1 PB",
+  "host_networking": "2x Mellanox ConnectX-5 Ex 100Gb/s Ethernet",
+  "host_networking_topology": "L3 Fat Tree",
+  "accelerators_per_node": "8",
+  "accelerator_model_name": "Intel® Gaudi® 2 AI Accelerator",
+  "accelerator_host_interconnect": "4x PCIe 4.0 x16",
+  "accelerator_frequency": "1800MHz",
+  "accelerator_on-chip_memories": "6",
+  "accelerator_memory_configuration": "HBM2E",
+  "accelerator_memory_capacity": "96 GB",
+  "accelerator_interconnect": "24x 100Gb/s Ethernet",
+  "accelerator_interconnect_topology": "10x L3 Fat Tree",
+  "cooling": "Air-cooled",
+  "hw_notes": "",
+  "framework": "PyTorch 2.0.1a0",
+  "other_software_stack": "synapseAI 1.13.99",
+  "operating_system": "Ubuntu 20.04",
+  "sw_notes": ""
+}

docker/bloom13b/Model-References/MLPERF3.1/Training/systems/HLS-Gaudi2-N8-PT.json

@@ -0,0 +1,35 @@
+{
+  "submitter": "Intel-HabanaLabs",
+  "division": "closed",
+  "status": "available",
+  "system_name": "HLS-Gaudi2-N8-PT",
+  "number_of_nodes": "8",
+  "host_processors_per_node": "2",
+  "host_processor_model_name": "Intel(R) Xeon(R) Platinum 8380",
+  "host_processor_core_count": "40",
+  "host_processor_vcpu_count": "80",
+  "host_processor_frequency": "2.3 GHz",
+  "host_processor_caches": "L1d cache: 3.8 MiB, L1i cache: 2.5 MiB, L2 cache: 100 MiB, L3 cache: 120 MiB",
+  "host_processor_interconnect": "UPI",
+  "host_memory_capacity": "1024 GB",
+  "host_memory_configuration": "DDR4-3200",
+  "host_storage_type": "Weka",
+  "host_storage_capacity": "1 PB",
+  "host_networking": "2x Mellanox ConnectX-5 Ex 100Gb/s Ethernet",
+  "host_networking_topology": "L3 Fat Tree",
+  "accelerators_per_node": "8",
+  "accelerator_model_name": "Intel® Gaudi® 2 AI Accelerator",
+  "accelerator_host_interconnect": "4x PCIe 4.0 x16",
+  "accelerator_frequency": "1800MHz",
+  "accelerator_on-chip_memories": "6",
+  "accelerator_memory_configuration": "HBM2E",
+  "accelerator_memory_capacity": "96 GB",
+  "accelerator_interconnect": "24x 100Gb/s Ethernet",
+  "accelerator_interconnect_topology": "10x L3 Fat Tree",
+  "cooling": "Air-cooled",
+  "hw_notes": "",
+  "framework": "PyTorch 2.0.1a0",
+  "other_software_stack": "synapseAI 1.12.0",
+  "operating_system": "Ubuntu 20.04",
+  "sw_notes": ""
+}

docker/bloom13b/Model-References/MLPERF3.1/Training/systems/HLS-Gaudi2-PT.json

@@ -0,0 +1,35 @@
+{
+  "submitter": "Intel-HabanaLabs",
+  "division": "closed",
+  "status": "available",
+  "system_name": "HLS-Gaudi2-PT",
+  "number_of_nodes": "1",
+  "host_processors_per_node": "2",
+  "host_processor_model_name": "Intel(R) Xeon(R) Platinum 8380",
+  "host_processor_core_count": "40",
+  "host_processor_vcpu_count": "80",
+  "host_processor_frequency": "2.3 GHz",
+  "host_processor_caches": "L1d cache: 3.8 MiB, L1i cache: 2.5 MiB, L2 cache: 100 MiB, L3 cache: 120 MiB",
+  "host_processor_interconnect": "UPI",
+  "host_memory_capacity": "1024 GB",
+  "host_memory_configuration": "DDR4-3200",
+  "host_storage_type": "Weka",
+  "host_storage_capacity": "1 PB",
+  "host_networking": "2x Mellanox ConnectX-5 Ex 100Gb/s Ethernet",
+  "host_networking_topology": "L3 Fat Tree",
+  "accelerators_per_node": "8",
+  "accelerator_model_name": "Intel® Gaudi® 2 AI Accelerator",
+  "accelerator_host_interconnect": "4x PCIe 4.0 x16",
+  "accelerator_frequency": "1800MHz",
+  "accelerator_on-chip_memories": "6",
+  "accelerator_memory_configuration": "HBM2E",
+  "accelerator_memory_capacity": "96 GB",
+  "accelerator_interconnect": "24x 100Gb/s Ethernet",
+  "accelerator_interconnect_topology": "10x L3 Fat Tree",
+  "cooling": "Air-cooled",
+  "hw_notes": "",
+  "framework": "PyTorch 2.0.1a0",
+  "other_software_stack": "synapseAI 1.13.99",
+  "operating_system": "Ubuntu 20.04",
+  "sw_notes": ""
+}

docker/bloom13b/Model-References/MLPERF3.1/Training/systems/HLS-Gaudi2-TF.json

@@ -0,0 +1,35 @@
+{
+  "submitter": "Intel-HabanaLabs",
+  "division": "closed",
+  "status": "available",
+  "system_name": "HLS-Gaudi2-TF",
+  "number_of_nodes": "1",
+  "host_processors_per_node": "2",
+  "host_processor_model_name": "Intel(R) Xeon(R) Platinum 8380",
+  "host_processor_core_count": "40",
+  "host_processor_vcpu_count": "80",
+  "host_processor_frequency": "2.3 GHz",
+  "host_processor_caches": "L1d cache: 3.8 MiB, L1i cache: 2.5 MiB, L2 cache: 100 MiB, L3 cache: 120 MiB",
+  "host_processor_interconnect": "UPI",
+  "host_memory_capacity": "1024 GB",
+  "host_memory_configuration": "DDR4-3200",
+  "host_storage_type": "Weka",
+  "host_storage_capacity": "1 PB",
+  "host_networking": "2x Mellanox ConnectX-5 Ex 100Gb/s Ethernet",
+  "host_networking_topology": "L3 Fat Tree",
+  "accelerators_per_node": "8",
+  "accelerator_model_name": "Intel® Gaudi® 2 AI Accelerator",
+  "accelerator_host_interconnect": "4x PCIe 4.0 x16",
+  "accelerator_frequency": "1800MHz",
+  "accelerator_on-chip_memories": "6",
+  "accelerator_memory_configuration": "HBM2E",
+  "accelerator_memory_capacity": "96 GB",
+  "accelerator_interconnect": "24x 100Gb/s Ethernet",
+  "accelerator_interconnect_topology": "10x L3 Fat Tree",
+  "cooling": "Air-cooled",
+  "hw_notes": "",
+  "framework": "TensorFlow 2.13.0",
+  "other_software_stack": "synapseAI 1.13.99",
+  "operating_system": "Ubuntu 20.04",
+  "sw_notes": ""
+}

docker/bloom13b/Model-References/TensorFlow/common/debug.py

@@ -0,0 +1,134 @@
+# 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 os
+import json
+try:
+    import horovod.tensorflow as hvd
+except ImportError:
+    hvd = None
+
+def horovod_enabled():
+  return hvd is not None and hvd.is_initialized()
+
+
+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, output_regex=None):
+        self._dump_root = dump_root
+        if horovod_enabled():
+            self._dump_root = os.path.join(
+                self._dump_root, f"rank_{hvd.rank()}")
+        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._output_regex = re.compile(output_regex) if isinstance(
+                output_regex, str) else output_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 not tf.__version__.startswith("2.2"):
+            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):
+                if self._output_regex is not None and not self._output_regex.match(output.name):
+                    logging.info("Skipped output: " + output.name)
+                    new_outputs.append(output)
+                    continue
+                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 not tf.__version__.startswith("2.2"):
+                    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/TensorFlow/common/tb_utils.py

@@ -0,0 +1,474 @@
+import os
+import time
+import tensorflow as tf
+from copy import deepcopy
+from collections import defaultdict
+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
+from tensorflow.python.training.session_run_hook import SessionRunHook, SessionRunArgs
+
+
+def _remove_prefix(s, prefix):
+    if s.startswith(prefix):
+        s = s[len(prefix):]
+    return s
+
+
+def _parse_precision(hparams: dict):
+    # Check if 'hparams' contain data type.
+    if 'dtype' in hparams or 'data_type' in hparams:
+        param_name = 'dtype' if 'dtype' in hparams else 'data_type'
+        return hparams[param_name]
+
+    # Check if bf16 conversion flags are set.
+    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(hparams)
+    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)
+        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,
+                 tags_to_print=None):
+        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
+        self._tags_to_print = tags_to_print
+        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 or
+            (self._tags_to_print is not None and tag in self._tags_to_print)):
+            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._global_step = 0
+        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):
+        # batch is index within current epoch, if we want to dump data through all epochs then we need to use global_step
+        self._should_trigger = self._timer.should_trigger_for_step(self._global_step)
+
+    def on_predict_batch_end(self, batch, logs=None):
+        self._global_step += 1
+
+    def on_train_batch_end(self, batch, logs=None):
+        step = self._global_step
+        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
+        self._global_step += 1
+
+    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
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+    def add_scalar(self, tag, value, global_step=None):
+        with tf.compat.v1.Graph().as_default():
+            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)
+
+class TensorBoardHook(SessionRunHook):
+    def __init__(self,
+                output_dir="",
+                profile_steps=""
+                ):
+        self.output_dir = output_dir
+        profile_steps_error_message = (
+        'profile_steps must be a comma separated pair of positive integers, '
+        'specifying the first and last steps to be profiled.'
+        )
+        try:
+            profile_steps = [int(i) for i in profile_steps.split(',')]
+        except ValueError:
+            raise ValueError(profile_steps_error_message)
+        if len(profile_steps) != 2:
+            raise ValueError(profile_steps_error_message)
+        self.start_step, self.stop_step = profile_steps
+        if self.start_step < 0 or self.start_step > self.stop_step:
+            raise ValueError(profile_steps_error_message)
+        self._step = 0
+
+    def before_run(self, run_context):
+        self._step += 1
+        if self._step == self.start_step:
+            tf.profiler.experimental.start(self.output_dir)
+        elif self._step == self.stop_step + 1:
+            tf.profiler.experimental.stop()
+
+        return SessionRunArgs({})
+
+
+class TimeToTrainKerasHook(Callback):
+    def __init__(self, output_dir=None, summary_writer=None):
+        self.writer = summary_writer or summary_ops_v2.create_file_writer_v2(output_dir)
+        self.counters = defaultdict(int)
+
+    def _add_event(self, tag, step):
+        if self.writer is not None:
+            with self.writer.as_default(), summary_ops_v2.always_record_summaries():
+                summary_ops_v2.scalar(tag, 0, step=step)
+
+    def on_epoch_begin(self, epoch, logs=None):
+        self._add_event("ttt/train/epoch/begin", epoch)
+
+    def on_epoch_end(self, epoch, logs=None):
+        self._add_event("ttt/train/epoch/end", epoch)
+
+    def on_train_begin(self, logs=None):
+        self._add_event("ttt/train/begin", self.counters["train"])
+
+    def on_train_end(self, logs=None):
+        self._add_event("ttt/train/end", self.counters["train"])
+        self.counters["train"] += 1
+
+    def on_test_begin(self, logs=None):
+        self._add_event("ttt/eval/begin", self.counters["eval"])
+
+    def on_test_end(self, logs=None):
+        self._add_event("ttt/eval/end", self.counters["eval"])
+        self.counters["eval"] += 1
+
+    def on_predict_begin(self, logs=None):
+        self._add_event("ttt/predict/begin", self.counters["predict"])
+
+    def on_predict_end(self, logs=None):
+        self._add_event("ttt/predict/end", self.counters["predict"])
+        self.counters["predict"] += 1
+
+
+class TimeToTrainEstimatorHook(tf.estimator.SessionRunHook):
+    def __init__(self, train_or_eval, output_dir):
+        assert train_or_eval in ("eval", "train")
+        self._summary_writer = None
+        self._output_dir = output_dir
+        self._tag = train_or_eval
+        self._counter = 0
+
+    def _add_event(self, tag, value):
+        summary = tf.compat.v1.Summary(
+            value=[
+                tf.compat.v1.Summary.Value(
+                    tag=tag,
+                    simple_value=0)
+            ]
+        )
+        event = tf.compat.v1.Event(summary=summary)
+        event.wall_time = time.time()
+        event.step = self._counter
+        self._summary_writer.add_event(event)
+
+    def begin(self):
+        if self._summary_writer is None and self._output_dir:
+            self._summary_writer = SummaryWriterCache.get(self._output_dir)
+        self._add_event(f"ttt/{self._tag}/begin", self._counter)
+
+    def after_create_session(self, session, coord):
+        pass
+
+    def before_run(self, run_context):
+        pass
+
+    def after_run(self, run_context, run_values):
+        pass
+
+    def end(self, session):
+        self._add_event(f"ttt/{self._tag}/end", self._counter)
+        self._counter += 1

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/data_generators/ops/pack_sequences_ops.cc

@@ -0,0 +1,168 @@
+#include "third_party/tensorflow/core/framework/op_kernel.h"
+#include "third_party/tensorflow/core/framework/shape_inference.h"
+#include "third_party/tensorflow/core/framework/tensor.h"
+#include "third_party/tensorflow/core/framework/types.h"
+
+namespace tensor2tensor {
+namespace {
+
+using ::tensorflow::DEVICE_CPU;
+using ::tensorflow::OpKernel;
+using ::tensorflow::OpKernelConstruction;
+using ::tensorflow::OpKernelContext;
+using ::tensorflow::Status;
+using ::tensorflow::Tensor;
+using ::tensorflow::TensorShape;
+using ::tensorflow::shape_inference::InferenceContext;
+
+// TODO(noam): this op packs a dataset of pairs of sequences (inputs, targets)
+// Generalize later to an arbitrary number of sequences.
+REGISTER_OP("PackSequences2")
+    .Input("inputs: int64")
+    .Input("targets: int64")
+    .Input("inputs_max_length: int32")
+    .Input("targets_max_length: int32")
+    .Output("inputs_packed: int64")
+    .Output("inputs_segmentation: int32")
+    .Output("inputs_position: int32")
+    .Output("targets_packed: int64")
+    .Output("targets_segmentation: int32")
+    .Output("targets_position: int32")
+    .SetShapeFn([](InferenceContext* ctx) {
+                  for (int i=0; i < ctx->num_outputs(); i++) {
+                    ctx->set_output(i, ctx->Matrix(ctx->UnknownDim(),
+                                                   ctx->UnknownDim()));
+                  }
+                  return Status::OK();
+                });
+
+class PackSequences2Op : public OpKernel {
+ public:
+  explicit PackSequences2Op(
+      OpKernelConstruction* ctx) : OpKernel(ctx) {
+  }
+
+  void Compute(OpKernelContext* ctx) override {
+    auto inputs = ctx->input(0).matrix<int64>();
+    auto targets = ctx->input(1).matrix<int64>();
+    int inputs_max_length = ctx->input(2).scalar<int32>()();
+    int targets_max_length = ctx->input(3).scalar<int32>()();
+    int n = inputs.dimension(0);
+    std::vector<int> inputs_lengths(n);
+    std::vector<int> targets_lengths(n);
+    int padded_inputs_length =
+        std::min(static_cast<int>(inputs.dimension(1)), inputs_max_length);
+    for (int i = 0; i < n; i++) {
+      for (int j = 0; j < padded_inputs_length; j++) {
+          if (inputs(i, j) != 0)
+            inputs_lengths[i]++;
+      }
+    }
+    int padded_targets_length =
+        std::min(static_cast<int>(targets.dimension(1)), targets_max_length);
+    for (int i = 0; i < n; i++) {
+      for (int j = 0; j < padded_targets_length; j++) {
+          if (targets(i, j) != 0)
+            targets_lengths[i]++;
+      }
+    }
+    int num_combined = 0;
+    std::vector<int> combined_inputs_length;
+    std::vector<int> combined_targets_length;
+    std::vector<std::vector<int> > combined_sequence_ids;
+    for (int seq_id = 0; seq_id < n; seq_id++) {
+      int inputs_length = inputs_lengths[seq_id];
+      int targets_length = targets_lengths[seq_id];
+      for (int combined_id = std::max(0, num_combined - 1000); true;
+           combined_id++) {
+        if (combined_id == num_combined) {
+          combined_inputs_length.push_back(inputs_length);
+          combined_targets_length.push_back(targets_length);
+          combined_sequence_ids.push_back(std::vector<int>(1, seq_id));
+          num_combined++;
+          break;
+        } else if (
+            (combined_inputs_length[combined_id] + inputs_length
+             <= inputs_max_length) &&
+            (combined_targets_length[combined_id] + targets_length
+             <= targets_max_length)) {
+          combined_inputs_length[combined_id] += inputs_length;
+          combined_targets_length[combined_id] += targets_length;
+          combined_sequence_ids[combined_id].push_back(seq_id);
+          break;
+        }
+      }
+    }
+
+    auto output_shape_inputs = TensorShape(
+        {static_cast<int64>(num_combined),
+         static_cast<int64>(inputs_max_length)});
+    auto output_shape_targets = TensorShape(
+        {static_cast<int64>(num_combined),
+         static_cast<int64>(targets_max_length)});
+
+    Tensor* inputs_packed;
+    OP_REQUIRES_OK(ctx, ctx->allocate_output(
+        0, output_shape_inputs, &inputs_packed));
+    auto inputs_packed_m = inputs_packed->matrix<int64>();
+    inputs_packed_m.setZero();
+
+    Tensor* inputs_segmentation;
+    OP_REQUIRES_OK(
+        ctx, ctx->allocate_output(
+            1, output_shape_inputs, &inputs_segmentation));
+    auto inputs_segmentation_m = inputs_segmentation->matrix<int32>();
+    inputs_segmentation_m.setZero();
+
+    Tensor* inputs_position;
+    OP_REQUIRES_OK(
+        ctx, ctx->allocate_output(2, output_shape_inputs, &inputs_position));
+    auto inputs_position_m = inputs_position->matrix<int32>();
+    inputs_position_m.setZero();
+
+    Tensor* targets_packed;
+    OP_REQUIRES_OK(ctx, ctx->allocate_output(
+        3, output_shape_targets, &targets_packed));
+    auto targets_packed_m = targets_packed->matrix<int64>();
+    targets_packed_m.setZero();
+
+    Tensor* targets_segmentation;
+    OP_REQUIRES_OK(
+        ctx, ctx->allocate_output(
+            4, output_shape_targets, &targets_segmentation));
+    auto targets_segmentation_m = targets_segmentation->matrix<int32>();
+    targets_segmentation_m.setZero();
+
+    Tensor* targets_position;
+    OP_REQUIRES_OK(
+        ctx, ctx->allocate_output(5, output_shape_targets, &targets_position));
+    auto targets_position_m = targets_position->matrix<int32>();
+    targets_position_m.setZero();
+
+    for (int combined_id = 0; combined_id < num_combined; combined_id++) {
+      int inputs_pos = 0;
+      int targets_pos = 0;
+      for (int i=0; i < combined_sequence_ids[combined_id].size(); i++) {
+        int seq_id = combined_sequence_ids[combined_id][i];
+        for (int j=0; j < inputs_lengths[seq_id]; j++) {
+          inputs_packed_m(combined_id, inputs_pos) = inputs(seq_id, j);
+          inputs_segmentation_m(combined_id, inputs_pos) = i + 1;
+          inputs_position_m(combined_id, inputs_pos) = j;
+          inputs_pos++;
+        }
+        for (int j=0; j < targets_lengths[seq_id]; j++) {
+          targets_packed_m(combined_id, targets_pos) = targets(seq_id, j);
+          targets_segmentation_m(combined_id, targets_pos) = i + 1;
+          targets_position_m(combined_id, targets_pos) = j;
+          targets_pos++;
+        }
+      }
+    }
+  }
+};
+
+REGISTER_KERNEL_BUILDER(Name("PackSequences2").Device(DEVICE_CPU),
+                        PackSequences2Op);
+
+}  // namespace
+}  // namespace tensor2tensor

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/data_generators/ops/pack_sequences_ops_test.py

@@ -0,0 +1,78 @@
+# coding=utf-8
+# Copyright 2021 The Tensor2Tensor Authors.
+#
+# 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.
+
+"""Tests for pack_sequences_ops."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from TensorFlow.nlp.transformer.data_generators.ops import pack_sequences_ops
+import tensorflow.compat.v1 as tf
+
+
+class PackSequencesOpsTest(tf.test.TestCase):
+
+  def test_pack_sequences(self):
+    inputs = [
+        [1, 2, 3],
+        [4, 5, 0],
+        [6, 0, 0],
+    ]
+    targets = [
+        [10, 0, 0],
+        [20, 30, 40],
+        [50, 60, 0],
+    ]
+    max_length = 5
+    (inputs_packed, inputs_segmentation, inputs_position,
+     targets_packed, targets_segmentation, targets_position) = (
+         pack_sequences_ops.pack_sequences2(
+             inputs, targets, max_length, max_length))
+    self.assertAllEqual(
+        inputs_packed, [
+            [1, 2, 3, 4, 5],
+            [6, 0, 0, 0, 0],
+        ])
+    self.assertAllEqual(
+        inputs_segmentation, [
+            [1, 1, 1, 2, 2],
+            [1, 0, 0, 0, 0],
+        ])
+    self.assertAllEqual(
+        inputs_position, [
+            [0, 1, 2, 0, 1],
+            [0, 0, 0, 0, 0],
+        ])
+    self.assertAllEqual(
+        targets_packed, [
+            [10, 20, 30, 40, 0],
+            [50, 60, 0, 0, 0],
+        ])
+    self.assertAllEqual(
+        targets_segmentation, [
+            [1, 2, 2, 2, 0],
+            [1, 1, 0, 0, 0],
+        ])
+    self.assertAllEqual(
+        targets_position, [
+            [0, 0, 1, 2, 0],
+            [0, 1, 0, 0, 0],
+        ])
+
+
+if __name__ == "__main__":
+  tf.enable_eager_execution()
+  tf.test.main()

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/data_generators/ops/subword_text_encoder.cc

@@ -0,0 +1,127 @@
+#include "third_party/py/tensor2tensor/data_generators/ops/subword_text_encoder.h"
+
+#include "third_party/absl/strings/str_cat.h"
+#include "third_party/absl/strings/str_split.h"
+#include "third_party/absl/strings/string_view.h"
+#include "third_party/icu/include/unicode/uchar.h"
+#include "third_party/icu/include/unicode/utf8.h"
+#include "third_party/tensorflow/core/framework/tensor.h"
+#include "third_party/tensorflow/core/platform/env.h"
+
+namespace tensor2tensor {
+namespace {
+
+using ::tensorflow::Env;
+
+// End of Sequence token ID to insert at end of encoded text.
+constexpr int64 kEosTokenId = 1;
+
+}  // namespace
+
+SubwordTextEncoder::SubwordTextEncoder(const std::string& vocab_filename) {
+  // TODO(ormandi): Add a unified vocabulary reader function.
+  std::string vocab_contents;
+  TF_CHECK_OK(
+      ReadFileToString(Env::Default(), vocab_filename, &vocab_contents));
+  std::vector<absl::string_view> vocab_list =
+      absl::StrSplit(vocab_contents, '\n');
+  // Strip trailing newline by skipping last element, then strip the first and
+  // last chars to remove enclosing quotes.
+  auto vocab_size = vocab_list.size() - vocab_list.back().empty();
+  for (auto i = 0; i < vocab_size; ++i) {
+    absl::string_view token =
+        vocab_list[i].substr(1, vocab_list[i].length() - 2);
+    int char_index = 0;
+    do {
+      // Note throughout that these strings are unicode so we iterate over utf-8
+      // code points, which may be between 8-32 bits long, using U8_NEXT. It is
+      // important never to iterate directly over ascii characters or models
+      // will fail to handle non-ascii alphabets properly.
+      UChar32 c;
+      U8_NEXT(token, char_index, token.length(), c);
+      CHECK_GE(c, 0);
+      alphabet_.insert(c);
+    } while (char_index < token.length());
+    vocab_.insert({std::string(token), i});
+  }
+}
+
+void SubwordTextEncoder::Encode(absl::string_view text, std::vector<int>* ids) {
+  ids->clear();
+  int token_start = 0;
+  int token_end = 0;
+  UChar32 c;
+  UChar32 next_c;
+  U8_NEXT(text, token_end, text.length(), c);
+  CHECK_GE(c, 0);
+  while (token_end <= text.length()) {
+    int next_end = token_end;
+    U8_NEXT(text, next_end, text.length(), next_c);
+    CHECK_GE(next_c, 0);
+    // Subtoken break when switching from non-alphanum to alphanum, or when
+    // reaching the end of the original token.
+    if (u_isalnum(next_c) != u_isalnum(c) || token_end >= text.length()) {
+      absl::string_view next_token =
+          text.substr(token_start, token_end - token_start);
+      if (next_token != " ") {
+        EncodeSubtokens(next_token, ids);
+      }
+      token_start = token_end;
+    }
+    token_end = next_end;
+    c = next_c;
+  }
+  ids->push_back(kEosTokenId);
+}
+
+void SubwordTextEncoder::EncodeSubtokens(
+    absl::string_view token, std::vector<int> *ids) {
+  std::string token_s = EscapeToken(token);
+  token = token_s;
+  int subtoken_start = 0;
+  // TODO(noam): this algorithm is quadratic in the length of the token.
+  //   We should instead start with a length equal to the maximum subtoken
+  //   length in the vocabulary.
+  int subtoken_end = token.length();
+  while (subtoken_start < token.length()) {
+    absl::string_view subtoken =
+        token.substr(subtoken_start, subtoken_end - subtoken_start);
+    auto iter = vocab_.find(subtoken);
+    if (iter != vocab_.end()) {
+      ids->push_back(iter->second);
+      subtoken_start = subtoken_end;
+      // TODO(noam): again, set subtoken_end forward only enough to catch
+      // the longest subtoken in the vocabulary.
+      subtoken_end = token.length();
+    } else {
+      U8_BACK_1((const uint8_t*)token_s.data(), 0, subtoken_end);
+      if (subtoken_end <= subtoken_start) {
+        LOG(FATAL) << "Unencodable tokens found.";
+      }
+    }
+  }
+}
+
+std::string SubwordTextEncoder::EscapeToken(absl::string_view token) {
+  std::string token_s;
+  int i = 0;
+  do {
+    int prev = i;
+    UChar32 c;
+    U8_NEXT(token, i, token.length(), c);
+    CHECK_GE(c, 0);
+    if (c == '_') {
+      absl::StrAppend(&token_s, "\\u");
+    } else if (c == '\\') {
+      absl::StrAppend(&token_s, "\\\\");
+    } else if (c == '\n' || alphabet_.find(c) == alphabet_.end()) {
+      absl::StrAppend(&token_s, "\\", c, ";");
+    } else {
+      absl::StrAppend(&token_s, token.substr(prev, i - prev));
+    }
+  } while (i < token.length());
+  absl::StrAppend(&token_s, "_");
+  return token_s;
+}
+
+}  // namespace tensor2tensor

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/data_generators/ops/subword_text_encoder.h

@@ -0,0 +1,44 @@
+#ifndef TENSOR2TESNOR_DATA_GENERATORS_OPS_SUBWORD_TEXT_ENCODER_H_
+#define TENSOR2TESNOR_DATA_GENERATORS_OPS_SUBWORD_TEXT_ENCODER_H_
+
+#include "third_party/absl/container/flat_hash_map.h"
+#include "third_party/absl/container/flat_hash_set.h"
+#include "third_party/absl/strings/string_view.h"
+#include "third_party/icu/include/unicode/uchar.h"
+#include "third_party/tensorflow/core/framework/tensor.h"
+
+namespace tensor2tensor {
+
+// A subword text encoder with built in tokenizer.
+//
+// Equivalent to tensor2tensor's subword text
+// https://github.com/tensorflow/tensor2tensor/blob/master/tensor2tensor/data_generators/text_encoder.py,
+// This code (or a suitable replacement) should eventually move into tfds
+//   and should be deleted from TensorFlow.nlp.transformer.
+
+class SubwordTextEncoder {
+ public:
+  explicit SubwordTextEncoder(const std::string& vocab_filename);
+  virtual ~SubwordTextEncoder() {}
+
+  // Breaks up input text into subtokens.
+  void Encode(absl::string_view text, std::vector<int>* ids);
+
+ private:
+  // Given a full token as input, breaks the token up into subtokens and appends
+  // corresponding IDs to the ids vector.
+  void EncodeSubtokens(absl::string_view token, std::vector<int>* ids);
+
+  // Escapes a token so unencodable characters are replaced by escape sequences.
+  std::string EscapeToken(absl::string_view token);
+
+  // Maps subword tokens to IDs.
+  absl::flat_hash_map<std::string, int64> vocab_;
+  // A set containing all valid unicode code points that can be encoded without
+  // being escaped.
+  absl::flat_hash_set<UChar32> alphabet_;
+};
+
+}  // namespace tensor2tensor
+
+#endif  // TENSOR2TESNOR_DATA_GENERATORS_OPS_SUBWORD_TEXT_ENCODER_H_

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/data_generators/ops/subword_text_encoder_ops.cc

@@ -0,0 +1,66 @@
+#include "third_party/py/tensor2tensor/data_generators/ops/subword_text_encoder.h"
+#include "third_party/tensorflow/core/framework/op_kernel.h"
+#include "third_party/tensorflow/core/framework/shape_inference.h"
+#include "third_party/tensorflow/core/framework/tensor.h"
+#include "third_party/tensorflow/core/framework/types.h"
+
+namespace tensor2tensor {
+namespace {
+
+using ::tensorflow::DEVICE_CPU;
+using ::tensorflow::OpKernel;
+using ::tensorflow::OpKernelConstruction;
+using ::tensorflow::OpKernelContext;
+using ::tensorflow::Status;
+using ::tensorflow::Tensor;
+using ::tensorflow::TensorShape;
+using ::tensorflow::tstring;
+using ::tensorflow::shape_inference::InferenceContext;
+
+REGISTER_OP("SubwordTextEncoderEncode")
+    .Input("s: string")
+    .Output("encoded: int64")
+    .Attr("vocab_filename: string")
+    .SetShapeFn([](InferenceContext* ctx) {
+      ctx->set_output(0, ctx->Vector(ctx->UnknownDim()));
+      return Status::OK();
+    });
+
+class SubwordTextEncoderEncodeOp : public OpKernel {
+ public:
+  explicit SubwordTextEncoderEncodeOp(
+      OpKernelConstruction* ctx) : OpKernel(ctx) {
+    std::string vocab_filename;
+    OP_REQUIRES_OK(ctx, ctx->GetAttr("vocab_filename", &vocab_filename));
+    encoder_ = absl::make_unique<SubwordTextEncoder>(vocab_filename);
+  }
+
+  void Compute(OpKernelContext* ctx) override {
+    // Get input string and deserialize into ArticleExample proto.
+    absl::string_view s = ctx->input(0).scalar<tstring>()();
+
+    // Construct encoded output tensors.
+    std::vector<int> encoded_ids;
+    encoder_->Encode(s, &encoded_ids);
+    Tensor* encoded;
+    OP_REQUIRES_OK(
+        ctx,
+        ctx->allocate_output(0, TensorShape(
+            {static_cast<int64>(encoded_ids.size())}), &encoded));
+    auto encoded_vec = encoded->vec<int64>();
+    // TODO(noam): find someone who remembers c++ eigen and ask the proper way
+    // to copy a std::Vector to an Eigen whatever-this-is
+    for (int i = 0; i < encoded_ids.size(); i++) {
+      encoded_vec(i) = encoded_ids[i];
+    }
+  }
+
+ private:
+  std::unique_ptr<SubwordTextEncoder> encoder_;
+};
+
+REGISTER_KERNEL_BUILDER(Name("SubwordTextEncoderEncode").Device(DEVICE_CPU),
+                        SubwordTextEncoderEncodeOp);
+
+}  // namespace
+}  // namespace tensor2tensor

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/data_generators/ops/subword_text_encoder_ops_test.py

@@ -0,0 +1,40 @@
+# coding=utf-8
+# Copyright 2021 The Tensor2Tensor Authors.
+#
+# 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.
+
+"""Tests for subword_text_encoder_ops."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from TensorFlow.nlp.transformer.data_generators.ops import subword_text_encoder_ops
+import tensorflow.compat.v1 as tf
+
+vocab_file = (
+    "third_party/py/tensor2tensor/data_generators/ops/testdata/subwords")
+
+
+class SubwordTextEncoderOpsTest(tf.test.TestCase):
+
+  def test_subword_text_encoder_encode(self):
+    s = "the quick brown fox jumps over the lazy dog"
+    encoded = subword_text_encoder_ops.subword_text_encoder_encode(
+        s, vocab_file)
+    self.assertAllEqual(encoded, [2, 3, 4, 5, 6, 7, 8, 9, 2, 11, 12, 1])
+
+
+if __name__ == "__main__":
+  tf.enable_eager_execution()
+  tf.test.main()

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/data_generators/ops/subword_text_encoder_test.cc

@@ -0,0 +1,44 @@
+#include "third_party/py/tensor2tensor/data_generators/ops/subword_text_encoder.h"
+
+#include "testing/base/public/gunit.h"
+#include "third_party/tensorflow/core/framework/tensor.h"
+#include "third_party/tensorflow/core/framework/tensor_testutil.h"
+
+namespace tensor2tensor {
+namespace {
+
+TEST(SubwordTextEncoderTest, EncodesSubTokens) {
+  SubwordTextEncoder encoder("third_party/py/tensor2tensor/"
+                             "data_generators/ops/testdata/subwords");
+  std::vector<int> t;
+  encoder.Encode("the quick brown fox jumps over the lazy dog", &t);
+  EXPECT_EQ(t, std::vector<int>({2, 3, 4, 5, 6, 7, 8, 9, 2, 11, 12, 1}));
+}
+
+TEST(SubwordTextEncoderTest, EncodesUnicodeSubTokens) {
+  SubwordTextEncoder encoder("third_party/py/tensor2tensor/"
+                             "data_generators/ops/testdata/subwords");
+  std::vector<int> t;
+  encoder.Encode("ɧęĻĽÒ", &t);
+  EXPECT_EQ(t, std::vector<int>({13, 14, 1}));
+}
+
+TEST(SubwordTextEncoderTest, EncodesUnicodeCodePoints) {
+  SubwordTextEncoder encoder("third_party/py/tensor2tensor/"
+                             "data_generators/ops/testdata/subwords");
+  std::vector<int> t;
+  encoder.Encode("⻦ ⻭", &t);
+  EXPECT_EQ(t, std::vector<int>({15, 18, 16, 17, 1}));
+}
+
+TEST(SubwordTextEncoderTest, EncodesCharactersNotInAlphabet) {
+  SubwordTextEncoder encoder("third_party/py/tensor2tensor/"
+                             "data_generators/ops/testdata/subwords");
+  std::vector<int> t;
+  encoder.Encode("!", &t);
+  // Subtokens: '\', '3', '3', ';', '_', '<eos>', '<pad>'.
+  EXPECT_EQ(t, std::vector<int>({19, 23, 23, 30, 17, 1}));
+}
+
+}  // namespace
+}  // namespace tensor2tensor

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/data_generators/ops/testdata/subwords

@@ -0,0 +1,31 @@
+'<pad>'
+'<eos>'
+'the_'
+'quick_'
+'brow'
+'n_'
+'fox_'
+'jump'
+'s_'
+'over_'
+'the_'
+'lazy_'
+'dog_'
+'ɧę'
+'ĻĽÒ_'
+'⻦'
+'⻭'
+'_'
+' '
+'\'
+'0'
+'1'
+'2'
+'3'
+'4'
+'5'
+'6'
+'7'
+'8'
+'9'
+';'