Accelerate documentation

Low precision training methods

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Low precision training methods

The release of new kinds of hardware led to the emergence of new training paradigms that better utilize them. Currently, this is in the form of training in 8-bit precision using packages such as TransformersEngine (TE) or torchao (native PyTorch FP8).

For an introduction to the topics discussed today, we recommend reviewing the low-precision usage guide as this documentation will reference it regularly.

A Quick Chart

Below is a quick chart showing the different bit-precisions for each solution during training:

Optimization LevelComputation(GEMM)CommWeightMaster WeightWeight GradientOptimizer States
FP16 AMPFP16FP32FP32N/AFP32FP32+FP32
Nvidia TEFP8FP32FP32N/AFP32FP32+FP32

TransformersEngine

TransformersEngine is the first solution to trying to train in 8-bit floating point. It works by using drop-in replacement layers for certain ones in a model that utilizes their FP8-engine to reduce the number of bits (such as 32 to 8) without degrading the final accuracy of the model.

Specifically, Accelerate will find and replace the following layers with TransformersEngine versions:

  • nn.LayerNorm for te.LayerNorm
  • nn.Linear for te.Linear

As a result we wind up with a model that has most of its layers in BF16, while some layers are in FP8 reducing some of the memory.

Anecdotally, we have noticed that performance gains don’t really start showing when using TransformerEngine until a large majority of the layers in the model are made up of those two layers to replace. As a result, only larger models have shown performance improvements when the number of parameters is around and upwards of a few billion.

The TransformerEngine can receive many different arguments that customize how it performs FP8 calculations and what they do. A full list of the arguments is available below:

  • margin: The margin to use for the gradient scaling.
  • interval: The interval to use for how often the scaling factor is recomputed.
  • fp8_format``: The format to use for the FP8 recipe. Must be one ofHYBRIDorE4M3. (GenerallyHYBRIDfor training,E4M3` for evaluation)
  • amax_history_len: The length of the history to use for the scaling factor computation
  • amax_compute_algo: The algorithm to use for the scaling factor computation. Must be one of max or most_recent.
  • override_linear_precision: Whether or not to execute fprop, dgrad, and wgrad GEMMS in higher precision.

You can customize each of these as part of utils.TERecipeKwargs to help optimize performance of your models.

If we notice in the chart mentioned earlier, TE simply casts the computation layers into FP8, while everything else is in FP32. As a result this winds up utilizing the most memory but does so with the benefit of guaranteeing the least amount of loss in end accuracy during training.

Update on GitHub