FasterTransformer BERT

The FasterTransformer BERT contains the optimized BERT model, Effective FasterTransformer and INT8 quantization inference.

Table Of Contents

• FasterTransformer BERT
  • Table Of Contents
  • Model architecture
    • Standard BERT and Effective FasterTransformer
  • Setup
    • Requirements
    • Build the FasterTransformer
      • Prepare
      • Build the project
  • How to use
    • Run FasterTransformer BERT on C++
    • Run FasterTransformer BERT on TensorFlow
    • Run FasterTransformer BERT on PyTorch
    • Run the PyTorch BERT sample with multi-GPU:
  • Performance
    • Multi-GPU BERT-6B performance on A100 and triton example
    • Single GPU BERT performance
      • BERT performance on A100 and TensorFlow
      • BERT performance on T4 and TensorFlow
      • BERT performance on V100 and TensorFlow
      • BERT performance comparison between T4, V100, A100 and A100 with MIG mode on TensorFlow
      • BERT performance comparison between different features on T4 and TensorFlow
      • BERT performance on A100 and PyTorch
      • BERT performance on A10 and PyTorch
      • BERT performance on T4 and PyTorch
      • BERT performance on V100 and PyTorch
    • Performance on BERT Applications: SQuAD MRPC
      • Performance of TensorFlow
      • Performance of PyTorch

Model architecture

Standard BERT and Effective FasterTransformer

The following configurations are supported in the FasterTransformer encoder.

• Batch size (B₁): smaller or equal to 4096
• Sequence length (S): smaller or equal to 4096. For INT8 mode=1, S should be a multiple of 32 when S > 384.
• Size per head (N): Even number and smaller than 128.
• Head number (H): Any number satisfying that H * N <= 1024 under FP32, or H * N <= 2048 under FP16.
• Data type: FP32, FP16, BF16, INT8 and FP8 (Experimental).
• Any number layer (N₁) if the memory is enough

In the FasterTransformer v1.0, we provide a highly optimized BERT-equivalent encoder model. Next, based on the idea of Effective Transformer, we further optimize BERT inference by removing the useless padding in FasterTransformer v2.1 and provide the Effective FasterTransformer. In FasterTransformer v3.0, we provide INT8 quantization inference to get better performance. In FasterTransformer v3.1, we optimize the INT8 kernels to improve the performance of INT8 inference and integrate the multi-head attention of TensorRT plugin into FasterTransformer. In FasterTransformer v4.0, we add the multi-head attention kernel to support FP16 on V100 and INT8 on T4, A100. The following graph demonstrates the flow chart of these optimization, except INT8. In FasterTransformer v5.0, we refactor the codes, encapsulating the mask building and padding removing into the Bert forward function, and add the sparsity feature of Ampere GPU to accelerate the GEMM. In FasterTransformer v5.1, we support multi-node multi-GPU inference on Bert FP16.

The BERT model is proposed by google in 2018. The encoder of FasterTransformer is equivalent to BERT model, but do lots of optimization. The leftmost flow of Fig. 1 shows the optimization in FasterTransformer. After optimization, FasterTransformer only uses 8 or 6 gemms (blue blocks) and 6 custom CUDA kernels (green blocks) to implement one transformer block.

For Effective FasterTransformer, the main idea is removing the padding of sentence to prevent computing the useless tokens. This method can save lots of time when the average sequence length of one batch is much smaller than the maximum sequence length. Fig. 2 shows the idea and the offset (in orange) we use. To implement the Effective FasterTransformer, we need to consider two problems. First, we need to remove the padding before BERT, and rebuild padding after leaving BERT to keep the shape of result. This is simple and only bring ignorable overhead. The second problem is the computing of multi-head attention. A naïve solution is rebuilding the padding before the multi-head attention and removing the padding after the multi-head attention, which demonstrate in the second flowchart of Fig. 1. Because we can fuse these rebuilding/removing into other kernels, the additional overheads are also ignorable.

To further improve the performance of multi head attention, we integrate the multi-head attention of TensorRT, which fuses the whole attention computing into one kernel. The source codes are here. This kernel supports Effective FasterTransformer and standard BERT model at the same time. The third and forth flowcharts in Fig. 1 shows the workflow. With such kernel, we do not worry the padding issue multi-head attention. This kernel requires another offset, which is also show in Fig. 2.

Besides, we find that the padding would affect the accuracy for some tasks although they should be useless. So, we recommend removing the padding in the final outputs of downstream tasks.

The arguments, inputs, and outputs of encoder:

• Constructor of BERT

• Input of BERT

• Output of BERT

Besides, notice that the multi-head attention kernel from TensorRT is powerful but have some limitation. First, this kernel requires Turing or new GPU and the size per head must be 64. When the conditions are not satisfied, we use original multi-head attention implementation of FasterTransformer. Second, it requires an additional sequence length offset like fig 2 shows. More details are in link. When the input has padding, the shape of the sequence length offset is [2 x B₁ + 1 ]. Assume there are three sentences with sequence length s₁, s₂ and s₃, and the sequence length after padding is S. Then the sequence length offset is [0, s₁, S, s₂ + S, 2 x S, 2 x S + s₃, 3 x S]. On the other hand, when we remove the padding, the shape of the sequence length offset is [B₁ + 1], and the sequence length offset is [0, s₁, s₁ + s₂, s₁ + s₂ + s₃ ]. Namely, the sequence length offset records the sequence length for each sentence. When we have padding, we view the padding as some independent sentences.

In FasterTransformer v4.0, we implement two pipelines of INT8 inference, as shown in Fig. 3. For int8_mode == 1 (int8v1), we don't quantize residual connection, use int32 as the output of int8 gemms and use per-channel quantization for weights. For int8_mode == 2 (int8v2), we quantize residual connection, use int8 as the output of int8 gemms and use per-tensor quantization for weights. Generally speaking, int8_mode == 1 will have higher accuracy while int8_mode == 2 will have better performance.

For INT8 inference, quantized model is needed. We provide TensorFlow quantization tool and sample codes, and PyTorch sample codes with TensorRT's quantization tool is also provided. Please refer to the README in bert-quantization/bert-tf-quantization and examples/pytorch/bert/bert-quantization-sparsity first.

In FasterTransformer v5.0, we support the sparsity gemm to leverage the sparsity feature of Ampere GPU. We also provide an example on PyTorch.

In FasterTransformer v5.1, we support the multi-GPU multi-node inference for BERT model.

Setup

The following section lists the requirements to use FasterTransformer BERT.

Requirements

• CMake >= 3.8 for Tensorflow, CMake >= 3.13 for PyTorch
• CUDA 11.0 or newer version
• Python: Only verify on python 3
• Tensorflow: Verify on 1.15, 1.13 and 1.14 should work.
• PyTorch: Verify on 1.8.0, >= 1.5.0 should work.

These components are readily available within the NGC TensorFlow/PyTorch Docker image below.

Ensure you have the following components:

• NVIDIA Docker and NGC container are recommended
• NVIDIA Pascal or Volta or Turing or Ampere based GPU

For more information about how to get started with NGC containers, see the following sections from the NVIDIA GPU Cloud Documentation and the Deep Learning Documentation:

• Getting Started Using NVIDIA GPU Cloud
• Accessing And Pulling From The NGC Container Registry
• Running TensorFlow
• Running PyTorch

For those unable to use the NGC container, to set up the required environment or create your own container, see the versioned NVIDIA Container Support Matrix.

Build the FasterTransformer

Prepare

You can choose the tensorflow version and python version you want. Here, we list some possible images:

To achieve best performance, we recommend to use the latest image. For example, running image `nvcr.io/nvidia/tensorflow:22.09-tf1-py3` by 

```bash
nvidia-docker run -ti --shm-size 5g --rm nvcr.io/nvidia/tensorflow:22.09-tf1-py3 bash
git clone https://github.com/NVIDIA/FasterTransformer.git
mkdir -p FasterTransformer/build
cd FasterTransformer/build
git submodule init && git submodule update
```

For pytorch, it is similar

```bash
nvidia-docker run -ti --shm-size 5g --rm nvcr.io/nvidia/pytorch:22.09-py3 bash
git clone https://github.com/NVIDIA/FasterTransformer.git
mkdir -p FasterTransformer/build
cd FasterTransformer/build
git submodule init && git submodule update
```

Build the project

• Note: the xx of -DSM=xx in following scripts means the compute capability of your GPU. The following table shows the compute capability of common GPUs.

By default, -DSM is set by 70, 75, 80 and 86. When users set more kinds of -DSM, it requires longer time to compile. So, we suggest setting the -DSM for the device you use only. Here, we use xx as an example due to convenience.

1. build with C++

   cmake -DSM=xx -DCMAKE_BUILD_TYPE=Release ..
   make -j12

2. build with TensorFlow

   Uses need to set the path of TensorFlow. For example, if we use nvcr.io/nvidia/tensorflow:22.09-tf1-py3, then

   cmake -DSM=xx -DCMAKE_BUILD_TYPE=Release -DBUILD_TF=ON -DTF_PATH=/usr/local/lib/python3.8/dist-packages/tensorflow_core/ ..
   make -j12 

3. build with PyTorch

   cmake -DSM=xx -DCMAKE_BUILD_TYPE=Release -DBUILD_PYT=ON -DBUILD_MULTI_GPU=ON ..
   make -j12

   This will build the TorchScript custom class. Please make sure that the PyTorch >= 1.5.0.

   If user want to use sparsity gemm on BERT, then you need to download and extract the cusparseLt library and build with -DSPARSITY_SUPPORT=ON -DCUSPARSELT_PATH=/the_extracted_cusparselt_path:

   wget https://developer.download.nvidia.com/compute/libcusparse-lt/0.1.0/local_installers/libcusparse_lt-linux-x86_64-0.1.0.2.tar.gz
   tar -xzvf libcusparse_lt-linux-x86_64-0.1.0.2.tar.gz
   cmake -DSM=xx -DCMAKE_BUILD_TYPE=Release -DBUILD_PYT=ON -DSPARSITY_SUPPORT=ON -DCUSPARSELT_PATH=/the_extracted_cusparselt_path ..
   make -j12

How to use

Run FasterTransformer BERT on C++

1. Generate the gemm_config.in file for FP32/FP16/BF16 and the igemm_config.in file for INT8

   The generation of best GEMM configuration is recommended no matter what platform we use when we use FasterTransformer. If we do not generate the configure file, the FasterTransformer will use the default configuration and the inference speed may be slower.

   Assume the settings of the BERT are as follows:

   • batch_size=32
   • sequence_length=32
   • head_number=12
   • size_per_head=64
   • data_type=0 (FP32) or 1 (FP16) or 2 (BF16)
   • int8_mode=0

   Then the following scripts can generate the best GEMM configuration under such settings and record the configuration into the gemm_config.in file.

   ./bin/bert_gemm 32 32 12 64 0 0 1 0

   If the application may have multiple different shapes (like different batch size), users can run multiple time and set is_append to be true. For example

   ./bin/bert_gemm 32 32 12 64 0 0 1 0 # bs 32, not append, will create a new gemm_config.ini
   ./bin/bert_gemm 64 32 12 64 0 0 1 1 # bs 64, append results in existed gemm_config.ini

   In the following subsection, we use the same settings and 12 transformer layers unless specified.

2. Run FasterTransformer BERT under FP32 on C++

   ./bin/bert_example runs the BERT in the C++. The arguments of bert_example is:

   ./bin/bert_example <batch_size> <num_layers> <sequence_length> <head_number> <size_per_head> <data_type> <is_remove_padding> <int8_mode>

   Data Type = 0 (FP32) or 1 (FP16) or 2 (BF16)

   Then the following scripts can run the BERT under the above settings.

   ./bin/bert_example 32 12 32 12 64 0 0

   The outputs should be like to the following:

   Device Tesla V100-PCIE-32GB
   before allocate free 29.46 GB total 31.75 GB
   After allocate free 29.41 GB used 2.34 GB total 31.75 GB
   [INFO] batch_size 32 seq_len 32 layer 12 FT-CPP-time 16.51 ms (100 iterations)

3. Run FasterTransformer BERT under FP16/BF16 on C++

   So far, we use the FP32 to run the FasterTransformer. If we use the volta or newer NVIDIA GPU, we can use tensor core when we use the FP16. BF16 is only supported after Ampere NVIDIA GPU (SM 80).

   To use the FP16, we only need to set the <data_type> flag to 1 like following:

   ./bin/bert_gemm 32 32 12 64 1 0
   ./bin/bert_example 32 12 32 12 64 1 0 0 

   To use the BF16, we only need to set the <data_type> flag to 2.

   Note that the configuration of FP32 and FP16/BF16 are different, so we need to generate the configuration again.

   The outputs should be like to the following:

   Device Tesla V100-PCIE-32GB
   before allocate free 29.46 GB total 31.75 GB
   After allocate free 29.43 GB used 2.32 GB total 31.75 GB
   [INFO] batch_size 32 seq_len 32 layer 12 FT-CPP-time 4.00 ms 

4. Run FasterTransformer BERT under INT8 on C++

   If we use the Turing or newer NVIDIA GPUs, we can use tensor core when we use the INT8.

   To use the INT8, we only need to set the <int8_mode> flag to 1 or 2 like following:

   #For int8_mode == 1
   ./bin/bert_gemm 32 32 12 64 1 1
   ./bin/bert_int8_example 32 12 32 12 64 1 0 1
   
   #For int8_mode == 2
   ./bin/bert_gemm 32 32 12 64 1 2
   ./bin/bert_int8_example 32 12 32 12 64 1 0 2

   Note that the configuration file of FP32/FP16 and INT8 are different, so we need to generate the configuration again. And the <is_use_fp16> is not necessarily 1, depending on what data type bias is.

   The outputs should be like to the following:

   #For int8_mode == 1
   Device Tesla T4
   Device Tesla T4
   before allocate free 14.64 GB total 14.76 GB
   After allocate free 14.62 GB used 0.13 GB total 14.76 GB
   [INFO] batch_size 32 seq_len 32 layer 12 FT-CPP-time 7.49 ms ( 50 iterations) 
   
   #For int8_mode == 2
   Device Tesla T4
   Device Tesla T4
   before allocate free 14.64 GB total 14.76 GB
   After allocate free 14.62 GB used 0.13 GB total 14.76 GB
   [INFO] batch_size 32 seq_len 32 layer 12 FT-CPP-time 4.79 ms ( 50 iterations)

5. Run Effective FasterTransformer under FP32 on C++

   To use the Effective FasterTransformer, we only need to set the <is_remove_padding> flag to 1 like following:

   ./bin/bert_gemm 32 32 12 64 0 0
   ./bin/bert_example 32 12 32 12 64 0 1 0

   The outputs should be like to the following:

   Device Tesla V100-PCIE-32GB
   before allocate free 29.46 GB total 31.75 GB
   After allocate free 29.40 GB used 2.35 GB total 31.75 GB
   [INFO] batch_size 32 seq_len 32 layer 12 FT-CPP-time 9.77 ms 

6. Run Effective FasterTransformer under INT8 on C++

   To use the Effective FasterTransformer under INT8, we need to set the <is_remove_padding> flag to 1 and <int8_mode> flag to 1 or 2 like following. Since the sequence length in INT8 should be a multiple of 32, Effective FasterTransformer could be a good choice for INT8.

   #For int8_mode == 1
   ./bin/bert_gemm 32 32 12 64 1 1
   ./bin/bert_int8_example 32 12 32 12 64 1 1 1
   
   #For int8_mode == 2
   ./bin/bert_gemm 32 32 12 64 1 2
   ./bin/bert_int8_example 32 12 32 12 64 1 1 2

   The outputs should be like to the following:

   #For int8_mode == 1
   Device Tesla T4
   Device Tesla T4
   before allocate free 14.64 GB total 14.76 GB
   After allocate free 14.62 GB used 0.14 GB total 14.76 GB
   [INFO] batch_size 32 seq_len 32 layer 12 FT-CPP-time 4.06 ms ( 50 iterations)
   
   
   #For int8_mode == 2
   Device Tesla T4
   Device Tesla T4
   before allocate free 14.64 GB total 14.76 GB
   After allocate free 14.62 GB used 0.14 GB total 14.76 GB
   [INFO] batch_size 32 seq_len 32 layer 12 FT-CPP-time 2.69 ms ( 50 iterations)

7. Run FasterTransformer under FP8 on C++ (Experimental)

   Note that FP8 is supported since Hopper and CUDA 11.8. Here, we use docker image nvcr.io/nvidia/pytorch:22.10-py3 to demonstrate

   nvidia-docker run -ti --shm-size 5g --rm nvcr.io/nvidia/pytorch:22.10-py3 bash
   git clone https://github.com/NVIDIA/FasterTransformer.git
   mkdir -p FasterTransformer/build
   cd FasterTransformer/build
   git submodule init && git submodule update
   cmake -DSM=90 -DCMAKE_BUILD_TYPE=Release -DENABLE_FP8=ON ..
   make -j12
   git lfs clone https://huggingface.co/bert-base-uncased
   python3 ../examples/pytorch/bert/utils/huggingface_bert_convert.py -i bert-base-uncased/ -o bert-base-uncased/ft_fp32/ -i_g 1
   python3 ../examples/pytorch/bert/utils/huggingface_bert_fp8_convert.py -i bert-base-uncased/ -o bert-base-uncased/ft_fp8/
   ./bin/bert_fp8_example 4 12 384 12 64 1 1 ./bert-base-uncased/

Run FasterTransformer BERT on TensorFlow

1. Run FasterTransformer encoder under FP32 on TensorFlow

   ./bin/bert_gemm 32 32 12 64 0 0
   python ../examples/tensorflow/bert/bert_example.py \
           --batch_size 32 \
           --max_seq_len 32 \
           --head_number 12 \
           --size_per_head 64 \
           --num_layer 12 \
           --data_type fp32 \
           --test_time 1

   The outputs should be like to the following:

   [INFO] Encoder TF v.s. FT with tensor input Cross check True
   [INFO] Max diff 5.4836273193359375e-06
   [INFO] min diff 0.0
   [INFO] Encoder TF v.s. EFF-FT with tensor input Cross check True
   [INFO] Max diff 4.76837158203125e-06
   [INFO] min diff 0.0
   [INFO] batch_size 32 max_seq_len 32 precision FP32 12 layer TF-while-time      44.49 ms ( 50 iterations)
   [INFO] batch_size 32 max_seq_len 32 precision FP32 12 layer FT-OP-while-time   44.30 ms ( 50 iterations)
   [INFO] batch_size 32 max_seq_len 32 precision FP32 12 layer EFF-OP-while-time  22.83 ms ( 50 iterations)

   Note: We can also generate the best GEMM configuration when running encoder by setting --allow_gemm_test True. Note: If users use Ampere GPUs, then TensorFlow will uses TF32 by default, and hence TensorFlow will be faster than FasterTransformer, and have large value differences.

2. Run FasterTransformer BERT under FP16 on TensorFlow

   To use the FP16 in TensorFlow, we only need to set the --data_type fp16 like following:

   ./bin/bert_gemm 32 32 12 64 1 0
   python ../examples/tensorflow/bert/bert_example.py \
           --batch_size 32 \
           --max_seq_len 32 \
           --head_number 12 \
           --size_per_head 64 \
           --num_layer 12 \
           --data_type fp16 \
           --test_time 1

   The outputs should be like to the following:

   [INFO] Encoder TF v.s. FT with tensor input Cross check True
   [INFO] Max diff 0.0234375
   [INFO] min diff 0.0
   [INFO] Encoder TF v.s. EFF-FT with tensor input Cross check False
   [INFO] Max diff 0.033203125
   [INFO] min diff 0.0
   [INFO] batch_size 32 max_seq_len 32 precision FP16 12 layer TF-while-time      12.27 ms ( 50 iterations)
   [INFO] batch_size 32 max_seq_len 32 precision FP16 12 layer FT-OP-while-time    8.59 ms ( 50 iterations)
   [INFO] batch_size 32 max_seq_len 32 precision FP16 12 layer EFF-OP-while-time   4.98 ms ( 50 iterations)

3. Run FasterTransformer and Effective FasterTransformer encoder under INT8 on TensorFlow

   To use the INT8 in TensorFlow, we only need to set the --int8_mode 1 or --int8_mode 2 like following:

   #For int8_mode == 1
   ./bin/bert_gemm 32 32 12 64 1 1
   python ../examples/tensorflow/bert/bert_example.py \
           --batch_size 32 \
           --max_seq_len 32 \
           --head_number 12 \
           --size_per_head 64 \
           --num_layer 12 \
           --data_type fp16 \
           --test_time 1 \
           --int8_mode 1
           
   #For int8_mode == 2
   ./bin/bert_gemm 32 32 12 64 1 2
   python ../examples/tensorflow/bert/bert_example.py \
           --batch_size 32 \
           --max_seq_len 32 \
           --head_number 12 \
           --size_per_head 64 \
           --num_layer 12 \
           --data_type fp16 \
           --test_time 1 \
           --int8_mode 2

   The outputs should be like to the following:

   #For int8_mode == 1
   [INFO] Encoder TF v.s. FT with tensor input Cross check False
   [INFO] Max diff 4.19140625
   [INFO] min diff 0.0
   [INFO] Encoder TF v.s. EFF-FT with tensor input Cross check False
   [INFO] Max diff 4.19140625
   [INFO] min diff 0.0
   [INFO] batch_size 32 max_seq_len 32 precision FP16 12 layer TF-while-time      12.64 ms ( 50 iterations)
   [INFO] batch_size 32 max_seq_len 32 precision INT8-v1 12 layer FT-OP-while-time    7.68 ms ( 50 iterations)
   [INFO] batch_size 32 max_seq_len 32 precision INT8-v1 12 layer EFF-OP-while-time   4.34 ms ( 50 iterations)
   
   #For int8_mode == 2
   [INFO] Encoder TF v.s. FT with tensor input Cross check False
   [INFO] Max diff 6.06640625
   [INFO] min diff 0.0
   [INFO] Encoder TF v.s. EFF-FT with tensor input Cross check False
   [INFO] Max diff 6.06640625
   [INFO] min diff 0.0
   [INFO] batch_size 32 max_seq_len 32 precision FP16 12 layer TF-while-time      12.47 ms ( 50 iterations)
   [INFO] batch_size 32 max_seq_len 32 precision INT8-v2 12 layer FT-OP-while-time    4.94 ms ( 50 iterations)
   [INFO] batch_size 32 max_seq_len 32 precision INT8-v2 12 layer EFF-OP-while-time   2.93 ms ( 50 iterations)

   Note: since we do not use the correct scales for quantization in this test, the Cross Check between TF and FT should fail.

4. Run FasterTransformer for GLUE dataset

   This subsection demonstrates how to integrate the FasterTransformer in TensorFlow and evaluate the accuracy of FasterTransformer on GLUE dataset. To evaluate on GLUE dataset, it requires the repo of BERT.

   1. Prepare the BERT codes, Download the BERT pretrained model.

   git clone https://github.com/google-research/bert.git tensorflow/tensorflow_bert/bert
   wget https://storage.googleapis.com/bert_models/2018_10_18/uncased_L-12_H-768_A-12.zip
   unzip uncased_L-12_H-768_A-12.zip
   2. Download the GLUE MRPC dataset. Note that the file download_glue_data.py can only executed under python3.

   wget https://gist.githubusercontent.com/W4ngatang/60c2bdb54d156a41194446737ce03e2e/raw/1502038877f6a88c225a34450793fbc3ea87eaba/download_glue_data.py
   python download_glue_data.py --tasks MRPC

   Note: If the download_glue_data.py has some issues, try to use this.

   3. Finetune the pretrained model on MRPC datasets. This takes some minutes.

   export BERT_BASE_DIR=${PWD}/uncased_L-12_H-768_A-12
   export GLUE_DIR=${PWD}/glue_data/
   
   python ../examples/tensorflow/bert/tensorflow_bert/bert/run_classifier.py \
         --task_name=MRPC \
         --do_train=true \
         --do_eval=true \
         --data_dir=$GLUE_DIR/MRPC \
         --vocab_file=$BERT_BASE_DIR/vocab.txt \
         --bert_config_file=$BERT_BASE_DIR/bert_config.json \
         --init_checkpoint=$BERT_BASE_DIR/bert_model.ckpt \
         --max_seq_length=128 \
         --train_batch_size=32 \
         --learning_rate=2e-5 \
         --num_train_epochs=3.0 \
         --output_dir=mrpc_output/

   The results would be like:

   INFO:tensorflow:***** Eval results *****
   I1204 01:22:58.318809 139767509075776 run_classifier.py:923] ***** Eval results *****
   INFO:tensorflow:  eval_accuracy = 0.84068626
   I1204 01:22:58.318926 139767509075776 run_classifier.py:925]   eval_accuracy = 0.84068626
   INFO:tensorflow:  eval_loss = 0.5026195
   I1204 01:22:58.319309 139767509075776 run_classifier.py:925]   eval_loss = 0.5026195
   INFO:tensorflow:  global_step = 343
   I1204 01:22:58.319446 139767509075776 run_classifier.py:925]   global_step = 343
   INFO:tensorflow:  loss = 0.5026195
   I1204 01:22:58.319561 139767509075776 run_classifier.py:925]   loss = 0.5026195
   
   4. Evaluate the accuracy of FasterTransformer under FP32

   To evaluate the accuracy of FasterTransformer, we can use tensorflow/tensorflow_bert/run_classifier_wrap.py. This file uses run_classifier.py of BERT repo, replacing the transformer model by FasterTransformer and add some additional arguments like --floatx.

   ./bin/bert_gemm 8 128 12 64 0 0
   python ../examples/tensorflow/bert/tensorflow_bert/run_classifier_wrap.py \
         --floatx=float32 \
         --task_name=MRPC \
         --do_eval=true \
         --data_dir=$GLUE_DIR/MRPC \
         --vocab_file=$BERT_BASE_DIR/vocab.txt \
         --bert_config_file=$BERT_BASE_DIR/bert_config.json \
         --init_checkpoint=mrpc_output/model.ckpt-343 \
         --max_seq_length=128 \
         --eval_batch_size=8 \
         --output_dir=mrpc_output

   The results would be like:

   INFO:tensorflow:***** Eval results *****
   I1204 01:25:59.202495 140314814412608 run_classifier.py:923] ***** Eval results *****
   INFO:tensorflow:  eval_accuracy = 0.84068626
   I1204 01:25:59.202617 140314814412608 run_classifier.py:925]   eval_accuracy = 0.84068626
   INFO:tensorflow:  eval_loss = 0.50261945
   I1204 01:25:59.202857 140314814412608 run_classifier.py:925]   eval_loss = 0.50261945
   INFO:tensorflow:  global_step = 343
   I1204 01:25:59.202969 140314814412608 run_classifier.py:925]   global_step = 343
   INFO:tensorflow:  loss = 0.50261945
   I1204 01:25:59.203072 140314814412608 run_classifier.py:925]   loss = 0.50261945
   5. Convert the finetuned checkpoint to FP16 and evaluate the accuracy of FasterTransformer under FP16.

   To convert the checkpoint from FP32 to FP16, we can use ../examples/tensorflow/bert/tensorflow_bert/ckpt_type_convert.py to convert the checkpoint. This file requires two arguments, the location of FP32 checkpoint, and the location putting the FP16 checkpoint.

   python ../examples/tensorflow/bert/tensorflow_bert/ckpt_type_convert.py \
         --init_checkpoint=mrpc_output/model.ckpt-343 \
         --fp16_checkpoint=mrpc_output_fp16/fp16_model.ckpt
   ./bin/bert_gemm 8 128 12 64 1 0
   python ../examples/tensorflow/bert/tensorflow_bert/run_classifier_wrap.py \
         --floatx=float16 \
         --task_name=MRPC \
         --do_eval=true \
         --data_dir=$GLUE_DIR/MRPC \
         --vocab_file=$BERT_BASE_DIR/vocab.txt \
         --bert_config_file=$BERT_BASE_DIR/bert_config.json \
         --init_checkpoint=mrpc_output_fp16/fp16_model.ckpt \
         --max_seq_length=128 \
         --eval_batch_size=8 \
         --output_dir=mrpc_output_fp16

   The results would be like:

   INFO:tensorflow:***** Eval results *****
   I1204 01:27:49.961906 139736813242176 run_classifier.py:923] ***** Eval results *****
   INFO:tensorflow:  eval_accuracy = 0.8504902
   I1204 01:27:49.962020 139736813242176 run_classifier.py:925]   eval_accuracy = 0.8504902
   INFO:tensorflow:  eval_loss = 0.5103425
   I1204 01:27:49.962350 139736813242176 run_classifier.py:925]   eval_loss = 0.5103425
   INFO:tensorflow:  global_step = 343
   I1204 01:27:49.962482 139736813242176 run_classifier.py:925]   global_step = 343
   INFO:tensorflow:  loss = 0.5103358
   I1204 01:27:49.962604 139736813242176 run_classifier.py:925]   loss = 0.5103358
   6. Compare the speed of BERT of TensorFlow and FasterTransformer under both FP32 and FP16.

   To compare the speed of TensorFlow and FasterTransformer on BERT model directly, we can use ../examples/tensorflow/bert/tensorflow_bert/profile_transformer_inferece.py.

   ./bin/bert_gemm 8 128 12 64 0 0
   python ../examples/tensorflow/bert/tensorflow_bert/profile_transformer_inference.py \
           --init_checkpoint=mrpc_output/model.ckpt-343 \
           --tf_profile=false \
           --output_dir=mrpc_output \
           --profiling_output_file=time_elapsed \
           --xla=true \
           --floatx=float32
   ./bin/bert_gemm 8 128 12 64 1 0
   python ../examples/tensorflow/bert/tensorflow_bert/profile_transformer_inference.py \
           --init_checkpoint=mrpc_output_fp16/fp16_model.ckpt \
           --tf_profile=false \
           --output_dir=mrpc_output_fp16 \
           --profiling_output_file=time_elapsed \
           --xla=true \
           --floatx=float16

   The results of FP32 would be like:

   average time (seconds) elapsed original tensorflow: 0.049444806575775144 sec
   average time (seconds) elapsed fast transformer: 0.046385574340820315 sec

   The results of FP16 would be like:

   average time (seconds) elapsed original tensorflow: 0.015163004398345947 sec
   average time (seconds) elapsed fast transformer: 0.009342837333679199 sec

5. Run FasterTransformer for SQuAD 1.1 dataset

   This subsection demonstrates how to integrate the FasterTransformer in TensorFlow and evaluates the accuracy of FasterTransformer on SQuAD 1.1 dataset. To evaluate on SQuAD 1.1 dataset, it requires the repo of BERT.

   1. Prepare the BERT codes and download the fine-tuned model of SQuAD 1.1 from NGC

   Because the training time of SQuAD is longer, and the NVIDIA NGC has provided the fine-tuned BERT model, we download the fine-tuned model directly.

   git clone https://github.com/google-research/bert.git tensorflow/tensorflow_bert/bert
   wget --content-disposition https://api.ngc.nvidia.com/v2/models/nvidia/bert_tf_ckpt_base_qa_squad11_amp_128/versions/19.03.1/zip -O bert_tf_ckpt_base_qa_squad11_amp_128_19.03.1.zip
   unzip bert_tf_ckpt_base_qa_squad11_amp_128_19.03.1.zip -d squad_model
   2. Download the SQuAD dataset.

   mkdir squad_data
   wget -P squad_data https://rajpurkar.github.io/SQuAD-explorer/dataset/train-v1.1.json
   wget -P squad_data https://rajpurkar.github.io/SQuAD-explorer/dataset/dev-v1.1.json
   3. Evaluate the accuracy of TensorFlow under FP32

   python ../examples/tensorflow/bert/tensorflow_bert/bert/run_squad.py \
   --predict_batch_size=8 \
   --vocab_file=squad_model/vocab.txt \
   --bert_config_file=squad_model/bert_config.json \
   --init_checkpoint=squad_model/model.ckpt \
   --train_file=squad_data/train-v1.1.json \
   --do_predict=True \
   --predict_file=squad_data/dev-v1.1.json \
   --max_seq_length=384 \
   --output_dir=./squad_tf_output/fp_32/
   
   python ../examples/tensorflow/bert/tensorflow_bert/squad_evaluate_v1_1.py squad_data/dev-v1.1.json squad_tf_output/fp_32/predictions.json

   The results of TensorFlow would be like:

   {"exact_match": 78.9120151371807, "f1": 86.22012390507868}
   4. Evaluate the accuracy of FasterTransformer under FP32

   To evaluate the accuracy of FasterTransformer, we can use ../examples/tensorflow/bert/tensorflow_bert/run_squad_wrap.py. This file uses run_squad.py of BERT repo, replacing the transformer model by FasterTransformer, and add some additional arguments like --floatx.

   ./bin/bert_gemm 8 384 12 64 0 0
   python ../examples/tensorflow/bert/tensorflow_bert/run_squad_wrap.py \
         --floatx=float32 \
         --predict_batch_size=8 \
         --vocab_file=squad_model/vocab.txt \
         --bert_config_file=squad_model/bert_config.json \
         --init_checkpoint=squad_model/model.ckpt \
         --train_file=squad_data/train-v1.1.json \
         --do_predict=True \
         --predict_file=squad_data/dev-v1.1.json \
         --max_seq_length=384 \
         --output_dir=./squad_ft_output/fp_32/ \
         --allow_gemm_test=False
   
   python ../examples/tensorflow/bert/tensorflow_bert/squad_evaluate_v1_1.py squad_data/dev-v1.1.json squad_ft_output/fp_32/predictions.json

   The results of TensorFlow would be like:

   {"exact_match": 78.9120151371807, "f1": 86.22012390507868}
   5. Convert the checkpoint to FP16 and evaluate the accuracy of TensorFlow and FasterTransformer under FP16

   To convert the checkpoint from FP32 to FP16, we can use tensorflow/tensorflow_bert/ckpt_type_convert.py to convert the checkpoint. This file requires two arguments, the location of FP32 checkpoint, and the location putting the FP16 checkpoint.

   python ../examples/tensorflow/ckpt_type_convert.py --init_checkpoint=squad_model/model.ckpt --fp16_checkpoint=squad_fp16_model/model.ckpt
   
   ./bin/bert_gemm 8 384 12 64 1 0
   python ../examples/tensorflow/bert/tensorflow_bert/run_squad_wrap.py \
         --floatx=float16 \
         --predict_batch_size=8 \
         --vocab_file=squad_model/vocab.txt \
         --bert_config_file=squad_model/bert_config.json \
         --init_checkpoint=squad_fp16_model/model.ckpt \
         --train_file=squad_data/train-v1.1.json \
         --do_predict=True \
         --predict_file=squad_data/dev-v1.1.json \
         --max_seq_length=384 \
         --output_dir=./squad_ft_output/fp_16/ \
         --allow_gemm_test=False
   
   python ../examples/tensorflow/bert/tensorflow_bert/squad_evaluate_v1_1.py squad_data/dev-v1.1.json squad_ft_output/fp_16/predictions.json

   The results of TensorFlow would be like:

   {"exact_match": 79.03500473036897, "f1": 86.23027825772257}
   6. Evaluate the accuracy of Effective FasterTransformer under FP16

   Since the total sequence length is not fixed, we recommend using the default gemm configuration directly for Effective FasterTransformer.

   python ../examples/tensorflow/bert/tensorflow_bert/run_squad_wrap.py \
       --floatx=float16 \
       --predict_batch_size=8 \
       --vocab_file=squad_model/vocab.txt \
       --bert_config_file=squad_model/bert_config.json \
       --init_checkpoint=squad_fp16_model/model.ckpt \
       --train_file=squad_data/train-v1.1.json \
       --do_predict=True \
       --predict_file=squad_data/dev-v1.1.json \
       --max_seq_length=384 \
       --output_dir=./squad_ft_output/fp_16/ \
       --allow_gemm_test=False \
       --remove_padding=True
   
   python ../examples/tensorflow/bert/tensorflow_bert/squad_evaluate_v1_1.py squad_data/dev-v1.1.json squad_ft_output/fp_16/predictions.json

   The results of TensorFlow would be like:

   {"exact_match": 79.04446546830653, "f1": 86.23343183703513}
   7. Evaluate the accuracy of FasterTransformer under INT8

   Please refer to the directory examples/tensorflow/bert/bert-quantization first for how to get a quantized model. In section 5.7 and section 5.8, to keep consistent with the procedures described in examples/tensorflow/bert/bert-quantization, we use https://storage.googleapis.com/bert_models/2020_02_20/uncased_L-12_H-768_A-12.zip as initial checkpoint with finetuned accuracy of <f1, exact_match> == <89.57, 82.44>.

   In bert-tf-quantization, we give detailed procedure of Post Training Quantization (PTQ), Quantization Aware Training (QAT) and QAT with Knowledge-distillation. Since they have the same inference procedure, we use QAT-KD checkpoint to show how to evaluate the accuracy of FasterTransformer under INT8.

   Suppose we already fine-tuned a FP32 checkpoint using QAT-KD with int8_mode == 2 as described in bert-quantization. The path to checkpoint is squad_model/QAT_KD_mode_2/.

   We first convert the checkpoint from FP32 to FP16 (this step is not necessary, but it will give us a better performance) and then quantize the FP16 checkpoint using ../examples/tensorflow/bert/tensorflow_bert/ckpt_quantization.py. This file requires three arguments, the location of initial checkpoint, the location putting the quantized checkpoint and the int8_mode.

   python ../examples/tensorflow/bert/tensorflow_bert/ckpt_type_convert.py --init_checkpoint=squad_model/QAT_KD_mode_2/model.ckpt-27374 --fp16_checkpoint=squad_model/QAT_KD_mode_2_fp16/model.ckpt
   
   python ../examples/tensorflow/bert/tensorflow_bert/ckpt_quantization.py --init_checkpoint=squad_model/QAT_KD_mode_2_fp16/model.ckpt --quantized_checkpoint=squad_model/QAT_KD_mode_2_fp16_quantized/model.ckpt --int8_mode=2
   
   ./bin/bert_gemm 8 384 12 64 1 1
   python ../examples/tensorflow/bert/tensorflow_bert/run_squad_wrap.py \
       --floatx=float16 \
       --predict_batch_size=8 \
       --vocab_file=squad_model/vocab.txt \
       --bert_config_file=squad_model/bert_config.json \
       --init_checkpoint=squad_model/QAT_KD_mode_2_fp16_quantized/model.ckpt \
       --train_file=squad_data/train-v1.1.json \
       --do_predict=True \
       --predict_file=squad_data/dev-v1.1.json \
       --max_seq_length=384 \
       --output_dir=./squad_ft_output/int8_mode_2/ \
       --int8_mode=2 \
       --allow_gemm_test=False
   
   python ../examples/tensorflow/bert/tensorflow_bert/squad_evaluate_v1_1.py squad_data/dev-v1.1.json squad_ft_output/int8_mode_2/predictions.json

   The results of TensorFlow would be like:

   {"exact_match": 83.85052034058657, "f1": 90.46351799300075}
   8. Evaluate the accuracy of Effective FasterTransformer under INT8

   To evaluate the accuracy of Effective FasterTransformer under INT8, we follow the steps described in above section to get the correct checkpoint, and then run ../examples/tensorflow/bert/tensorflow_bert/run_squad_wrap.py with --remove_padding True flag.

   ./bin/bert_gemm 8 384 12 64 1 1
   python ../examples/tensorflow/bert/tensorflow_bert/run_squad_wrap.py \
       --floatx=float16 \
       --predict_batch_size=8 \
       --vocab_file=squad_model/vocab.txt \
       --bert_config_file=squad_model/bert_config.json \
       --init_checkpoint=squad_model/QAT_KD_mode_2_fp16_quantized/model.ckpt \
       --train_file=squad_data/train-v1.1.json \
       --do_predict=True \
       --predict_file=squad_data/dev-v1.1.json \
       --max_seq_length=384 \
       --output_dir=./squad_ft_output/int8_mode_2_effectiveTransformer/ \
       --remove_padding=True \
       --int8_mode=2 \
       --allow_gemm_test=False
   
   python ../examples/tensorflow/bert/tensorflow_bert/squad_evaluate_v1_1.py squad_data/dev-v1.1.json squad_ft_output/int8_mode_2_effectiveTransformer/predictions.json

   The results of TensorFlow would be like:

   {"exact_match": 83.85052034058657, "f1": 90.46351799300075}

Run FasterTransformer BERT on PyTorch

Please install HuggingFace's `transformers` first before running the demos by

```bash
pip install transformers==2.5.1
```

1. Generate the gemm_config.in file:

   ./bin/bert_gemm <batch_size> <sequence_length> <head_number> <size_per_head> <data_type> <int8_mode>
   ./bin/bert_gemm 1 32 12 64 1 0

   Data Type = 0 (FP32) or 1 (FP16) or 2 (BF16)

   If you want to use the library in other directory, please generate this file according to your setting and copy it to your working directory.

2. Run the PyTorch BERT sample:

   python ../examples/pytorch/bert/bert_example.py <batch_size> <layer_num> <sequence_length> <head_number> <size_per_head> <--data_type fp32/fp16/bf16> <--int8_mode 0/1/2/3> <--sparse> <--time>
   python ../examples/pytorch/bert/bert_example.py 1 12 32 12 64 --data_type fp16 --time

   Set --data_type fp32 for fp32 mode, and set --data_type bf16 for bf16 mode. --int8_mode 1 or --int8_mode 2 or --int8_mode 3 will use int8_mode 1 or 2 or 3 in FasterTransformer. --sparse will use Ampere sparsity feature if FasterTransformer is built with sparsity support.

   The outputs should be like to the following:

   FT Mean diff: 0.0004119873046875
   FT Max diff:  0.00830078125
   FT Min diff:  0.0
   EFF-FT Mean diff: 0.0004119873046875
   EFF-FT Max diff:  0.00830078125
   EFF-FT Min diff:  0.0
   [INFO] HuggingFaceEnocder time costs:    5.77 ms
   [INFO] FasterTransformer time costs:     1.12 ms
   [INFO] EFF-FasterTransformer time costs: 1.33 ms

3. Run the BERT MRPC sample code:

   bash ../examples/pytorch/bert/scripts/run_mrpc.sh <model_type> <data_type>

   the <mode_type> can be:

   • ori: original HuggingFace's BERT encoder
   • ths: original HuggingFace's BERT encoder in TorchScript mode
   • thsext: our TorchScript custom class

   the <data_type> can be fp32 or fp16 or bf16

   For example, run HuggingFace's BERT under FP32 by following scripts:

   bash ../examples/pytorch/bert/scripts/run_mrpc.sh ori fp32

   The outputs should be like to the following:

   06/28/2020 07:29:59 - INFO - __main__ -     Evaluation for mrpc done in total 4.646116 secs (0.011388 sec per example)
   06/28/2020 07:29:59 - INFO - __main__ -   ***** Eval results  *****
   06/28/2020 07:29:59 - INFO - __main__ -     acc = 0.8284313725490197
   06/28/2020 07:29:59 - INFO - __main__ -     acc_and_f1 = 0.8556872581808643
   06/28/2020 07:29:59 - INFO - __main__ -     f1 = 0.8829431438127091

   For example, run our PyTorch custom op under FP16 by following scripts:

   bash ../examples/pytorch/bert/scripts/run_mrpc.sh thsext fp16

   The outputs should be like to the following:

   06/28/2020 07:30:19 - INFO - __main__ -     Evaluation for mrpc done in total 1.725153 secs (0.004228 sec per example)
   06/28/2020 07:30:19 - INFO - __main__ -   ***** Eval results  *****
   06/28/2020 07:30:19 - INFO - __main__ -     acc = 0.8284313725490197
   06/28/2020 07:30:19 - INFO - __main__ -     acc_and_f1 = 0.8556872581808643
   06/28/2020 07:30:19 - INFO - __main__ -     f1 = 0.8829431438127091

4. Run the BERT SQuAD sample code:

   bash ../examples/pytorch/bert/scripts/run_squad.sh --mtype <model_type> --dtype <date_type> --path <model_path> --head_num <head_num> --head_size <head_size> --bs <batch_size> --seqlen <max_seq_len> --sparse <if_use_sparse> --remove_padding <if_remove_padding>
   • the <mode_type> can be:
     • ori: original HuggingFace's BERT encoder
     • ths: original HuggingFace's BERT encoder in TorchScript mode
     • thsext: our TorchScript custom class
   • the <data_type> can be fp32 or fp16 or bf16 or int8_1 or int8_2 or int8_3
   • <model_path> is the directory containing the checkpoint
   • <head_num>, <head_size>, <batch_size>, and <max_seq_len> are the model and running parameters
   • <if_use_sparse> can be true or false
   • <if_remove_padding> can be true or false

   For example, run our PyTorch custom op under FP16 by following scripts (using HuggingFace's checkpoint):

   bash ../examples/pytorch/bert/scripts/run_squad.sh --mtype thsext --dtype fp16

   If we want to do INT8 or sparse tests, please refer to the directory examples/pytorch/bert/bert-quantization-sparsity first for how to get a trained model. After we obtained a model checkpoint, we can run it by specify the <model_path> and the related parameters. For example, run a BERT base model with INT8 mode 2 and sparse mode (need to do sparse training and QAT simultaneously for the checkpoint):

   bash ../examples/pytorch/bert/scripts/run_squad.sh \
       --mtype thsext \
       --dtype int8_2 \
       --path <the_trained_model_path> \
       --head_num 12 \
       -head_size 64 \
       --sparse true

Run the PyTorch BERT sample with multi-GPU:

Since v5.1, FasterTransformer supports multi-node multi-GPU inference on BERT model under FP32, FP16 and BF16. Users can use `--tensor_para_size` and `pipeline_para_size` to control the tensor parallelism and pipeline parallelism.

```bash
mpirun -n 4 python3 ../examples/pytorch/bert/bert_example.py 32 12 32 12 64 --data_type fp16 --tensor_para_size 2 --pipeline_para_size 2
```

* Note that multi-node inference is also supported. The usage is same to multi-GPU under MPI.
* Note that the performances under model parallelism are affected by the hardware and network significantly. If your GPUs are connected by PCIe, using model parallelism may bring few speedup or even worse performance.

Performance

Hardware settings:

• A100 (with mclk 1593MHz, pclk 1410MHz) with AMD EPYC 7742 64-Core Processor
• T4 (with mclk 5000MHz, pclk 1590MHz) with Intel(R) Xeon(R) CPU E5-2670 0 @ 2.60GHz
• V100 (with mclk 877MHz, pclk 1380MHz) with Intel(R) Xeon(R) CPU E5-2698 v4 @ 2.20GHz (dgx-1 server)
• A10 (with mclk 6251, pclk 1695) with AMD EPYC 7232P 8-Core Processor

Note that the CPU may affect the performance when the batch size and sequence length are small.

To run the following benchmark, we need to install the unix computing tool "bc" by

apt-get install bc

Multi-GPU BERT-6B performance on A100 and triton example

These benchmarks are ran by bert_triton_example.cc. These benchmark compare the performance of different model parallelism size. The GPUs are connected by NVLink. Note that for model parallelism, there are large effects on hardware and network.

The model configuration are:

• head_num = 32

• size_per_head = 128

• num_layers = 32

• Compare tensor parallelism (TP) and pipeline parallelism (PP)

• Compare scaling of different tensor parallelism (TP)

Single GPU BERT performance

We demonstrate the inference time of FasterTransformer in C++, TensorFlow and PyTorch, and compared to the performance on A100, T4 and V100.

For the benchmark of TensorFlow, we compare the performance of TensorFlow with XLA (TF), the performance of TensorFlow with FasterTransformer OP (FT) and the performance of TensorFlow with Effective FasterTransformer (EFF-FT), and show the speedup of FT and EFF-FT compared to the TensorFlow. Compared to v3.1, we modify the profiling method to hide the overhead of session run and memory copy. Thus, both TensorFlow and FasterTransformer are faster than v3.1 in TensorFlow benchmark on small batch size and sequence length. Because this new method has no obvious overhead compared to the FasterTransformer on C++, we skip the comparison with the C++ implementation.

For the benchmark of PyTorch, we compare the performance of TorchScript and the performance of PyTorch with FasterTransformer custom extension (CustomExt) and show the speedup of CustomExt compared to the TorchScript. For standard PyTorch implementation, we find that its performance is smaller or close to TorchScript, so we only demonstrate the performance of TorchScript. Besides, because CustomExt has no obvious overhead compared to the FasterTransformer on C++, we skip the comparison with the C++ implementation.

The FP32/FP16 results of C++ and TensorFlow were obtained by running the benchmarks/bert/tf_benchmark.sh.

The INT8 results of C++ and TensorFlow were obtained by running the sample/tensorflow/scripts/profile_encoder_performance_int8.sh.

The FP32/FP16 results of PyTorch were obtained by running the sample/pytorch/scripts/profile_encoder.sh.

The FP32/FP16 results of PyTorch were obtained by running the sample/pytorch/scripts/profile_encoder_int8.sh.

In the experiments of encoder, we updated the following parameters:

• head_num = 12
• size_per_head = 64
• num_layers = 12
• EFF-FT: Use remove padding. The avereage sequence length is set to half of Seq_len. For example, when Seq_len is 128, the real sequence length is 64, and other 64 tokens are paddings.

BERT performance on A100 and TensorFlow

• Performance on FP32

User can use export NVIDIA_TF32_OVERRIDE=0 to enforce the program run under FP32.

• Performance on TF32 (Note that the absolute differences of results under TF32 are larger than FP32.)

User can use export NVIDIA_TF32_OVERRIDE=1 to enforce the program run under TF32.

• Performance on FP16

• Performance on INT8-v1

• Performance on INT8-v2

Note that the INT8-v2 leads to larger overhead because some optimization requires the weights of Q, K and V are continuous. Using c API or preprocess the model can bring better performance.

BERT performance on T4 and TensorFlow

• Performance on FP32

• Performance on FP16

• Performance on INT8-v1

• Performance on INT8-v2

BERT performance on V100 and TensorFlow

• Performance on FP32

• Performance on FP16

BERT performance comparison between T4, V100, A100 and A100 with MIG mode on TensorFlow

• Performance of EFF-FT on FP16

• Performance of EFF-FT on INT8-v2

BERT performance comparison between different features on T4 and TensorFlow

BERT performance on A100 and PyTorch

• Performance on TF32

User can use export NVIDIA_TF32_OVERRIDE=1 to enforce the program run under TF32.

• Performance on FP16

• Performance on FP16 sparsity

• Performance on INT8-v1

• Performance on INT8-v2

• Performance on INT8-v2 sparsity

BERT performance on A10 and PyTorch

• Performance on FP32

• Performance on FP16

• Performance on INT8-v1

• Performance on INT8-v2

BERT performance on T4 and PyTorch

• Performance on FP32

• Performance on FP16

• Performance on INT8-v1

• Performance on INT8-v2

BERT performance on V100 and PyTorch

• Performance on FP32

• Performance on FP16

Performance on BERT Applications: SQuAD MRPC

Performance of TensorFlow

• [BERT-base-SQuAD-1.1 model]( For FP32/FP16, we use https://api.ngc.nvidia.com/v2/models/nvidia/bert_tf_ckpt_base_qa_squad11_amp_128/versions/19.03.1/zip; for INT8, we use https://storage.googleapis.com/bert_models/2020_02_20/uncased_L-12_H-768_A-12.zip, finetune it with FP32 precision and then use QAT-KD to generate INT8 checkpoint.), batch size 8, sequence length 128, on T4.

We use tensorflow/tensorflow_bert/profile_transformer_inference.py to generate the following results.

Performance of PyTorch

• BERT-large-SQuAD-1.1, dev set: batch size 8, seq len 384, on T4

Note *: the checkpoint for INT8 is QAT-finetuned with knowledge-distillation by ourselves, and is different with others, so the accuracy is not comparable, the corresponding FP16 accuracy is F1/EM: 92.89%/86.62%.

• BERT-base-MRPC, dev set: batch size 8, seq len 128, on T4