Inference Using FP8
On this Page
Inference Using FP8¶
This guide provides the steps required to enable FP8 inference on your Intel® Gaudi® 2 AI accelerator. When running inference on large language models (LLM) high memory usage is often the bottleneck. Therefore, using FP8 data type for inference on large language models halves the required memory bandwidth. In addition, FP8 compute is twice as fast as BF16 compute, so even compute-bound workloads, such as offline inference on large batch sizes, benefit.
Quantization Toolkit¶
Intel Gaudi provides a Quantization Toolkit (HQT) containing model measurement and quantization capabilities for FP8 in PyTorch models with Gaudi 2. The Quantization Toolkit provides these capabilities for models that include the modules listed in Supported Modules. The Quantization Toolkit is optimized for Gaudi 2 by:
Using PyTorch custom ops that allow fusion and optimizations at the Intel Gaudi software graph level.
Using specific scale values that have dedicated acceleration on Gaudi 2.
Using efficient memory loading to the device, loading the weights one by one and immediately converting them to FP8 to allow large models to fit on the device.
To enable and run the Quantization Toolkit:
Add some code modifications in your model script.
Run HQT in measurement mode to measure statistics and calculate scales based on the measurements.
Run HQT in quantization mode to automatically quantize the model to FP8 where possible.
Run verbose logging to print patched modules.
Note
HQT also supports DeepSpeed models.
Measurement and Quantization Mechanisms¶
The Quantization Toolkit measures statistics, calculates scales based on the measurements, and quantizes the model to FP8 where possible.
HQT runs in both measurement and quantization modes using the same API call which requires minimal changes to your code.
The QUANT_CONFIG
environment variable controls HQT and determines which mode should run.
Measurement mode - In this mode, HQT measures the statistics of the data flowing through the model. This is achieved by replacing the Supported Modules in the model before it runs on the dataset. It measures data statistics, such as the maximum absolute value (max abs), and outputs these statistics into a file. The purpose of this mode is to measure and store the data statistics relevant for quantization mode.
Quantization mode - Once the data statistics have been measured and saved, the model can be quantized. In this mode, HQT prepares the model to run in FP8. This includes loading the measurements file, calculating the scale of each tensor from its measurement, and injecting scale and cast operations into the model around operations that were selected to run in FP8. The purpose of this mode is to modify the model so that it can run using the FP8 data type, which can improve the performance of the model.
Supported Modules¶
Linear nn.Module
is supported and replaced by HQT during quantization.
In DeepSpeed, LinearAllreduce
, LinearLayer
, and LmHeadLinearAllreduce
modules are supported. In Transformers, FalconLinear
is supported.
In diffusers, LoRACompatibleLinear
and LoRACompatibleConv
modules are supported partially.
They can be applied in quantization only when their lora_layer
member is not used.
In case your model contains those modules with lora_layer
used, add them to blocklist
field in the json config file.
Supported Functions¶
In addition to the above supported modules, torch.matmul
and torch.nn.functional.softmax
are supported and replaced by HQT during quantization.
You can simply wrap each function with an nn.module
. See the below example:
class Matmul(nn.Module):
def __init__(self):
super().__init__()
def forward(self, *args, **kwargs):
return torch.matmul(*args, **kwargs)
Custom Patched Modules¶
Custom modules were added to topologies and corresponding quantized modules to HQT allowing quantization of more code in the user script, for example in LLAMAv2 model in Optimum Habana repo. The following replaces the existing code: KVCache and ScopedLinearAllReduce
Enabling and Running HQT in PyTorch Models¶
The Quantization Toolkit, habana_quantization_toolkit
, is installed with the Intel Gaudi PyTorch package. See the Installation Guide and On-Premise System Update for more details.
See LLAMAv2 model in Optimum Habana repo for an example model using HQT.
Follow the below steps to prepare your model script using HQT:
Call
hpu_set_env()
to enable inference optimizations:import habana_frameworks.torch.core as htcore htcore.hpu_set_env()
Call
prep_model(model)
after loading the model to set up HQT.prep_model(model)
replaces the supported modules with measured and quantized modules:from quantization_toolkit import habana_quantization_toolkit habana_quantization_toolkit.prep_model(model)
If DeepSpeed is used, call
prep_model(model)
afterinit_inference
. The below shows a full initialization with DeepSpeed example:import habana_frameworks.torch.core as htcore htcore.hpu_set_env() model = deepspeed.init_inference(model, **ds_inference_kwargs) model = model.module from quantization_toolkit import habana_quantization_toolkit habana_quantization_toolkit.prep_model(model)
The below call is also required in any inference scenario. It enables weights constant folding in the Intel Gaudi software:
htcore.hpu_initialize(model)
At the end of the run, call
finish_measurements
which saves the measurements to file. This call does not affect quantization mode:habana_quantization_toolkit.finish_measurements(model)
Running HQT in Measurement Mode¶
Create a config json file for measurement. The json is loaded and configured by HQT. Refer to Supported JSON Config File Options for more information. Use the following json example:
{ "method": "HOOKS", "mode": "MEASURE", "observer": "maxabs", "allowlist": {"types": [], "names": []}, "blocklist": {"types": [], "names": []}, "dump_stats_path": "./hqt_output/measure", "dump_stats_xlsx_path": "./hqt_output/measure/fp8stats.xlsx" }
Run measurement on your model by setting the
QUANT_CONFIG
environment variable with the json file path in the model run command:QUANT_CONFIG=maxabs_measure.json <model run command>
Running HQT in Quantization Mode¶
Create a config json file for quantization. The json file is loaded and configured by HQT. Refer to Supported JSON Config File Options for more information. Note that the
dump_stats_path
attribute should have the same path used in the measurement json file. Use the following json example for per-tensor quantization:{ "method": "HOOKS", "mode": "QUANTIZE", "observer": "maxabs", "scale_method": "maxabs_hw", "allowlist": {"types": [], "names": []}, "blocklist": {"types": [], "names": ["lm_head"]}, "dump_stats_path": "./hqt_output/measure", "dump_stats_xlsx_path": "./hqt_output/measure/fp8stats.xlsx" }
Alternatively, use this json example for weights-per-channel, activations-per-tensor quantization:
{ "method": "HOOKS", "mode": "QUANTIZE", "observer": "maxabs", "scale_method": "ACT_MAXABS_POW2_WEIGHTS_PCS_OPT_POW2", "whitelist": {"types": [], "names": []}, "blacklist": {"types": [], "names": []}, "dump_stats_path": "./hqt_output/measure", "dump_stats_xlsx_path": "./hqt_output/measure/fp8stats.xlsx" }
Run your quantized model by setting the
QUANT_CONFIG
environment variable with the path to the json file in the model run command:QUANT_CONFIG=maxabs_quant.json <model run command>
Set the
QUANT_VERBOSE=1
environment variable to print the status of the patched modules which HQT replaced, in addition to more debug prints. Search for “Patched modules” in the printed output.
Supported JSON Config File Options¶
The following table summarizes the options for the json config file:
Attribute |
Description |
Values |
---|---|---|
Method |
The mechanism to perform measurement and quantization. This is a mandatory attribute. |
|
Mode |
The mode, measure or quantize, to run HQT with. |
|
Observer |
The observer to measure the statistics. |
|
Allowlist |
List of nn.Module names or types to quantize. When setting an empty list, all the supported modules will be quantized by default. See Supported Modules. Not setting the list at all is not recommended as it will set the allowlist to these modules only: |
Default = empty list |
Blocklist |
List of nn.Module names or types not to quantize. Defaults to empty list, so you may omit it from the config file. |
Default = empty list |
dump_stats_path |
The path to save and load the measurements. The path is created up until the level before last “/”. The string after the last / will be used as prefix to all the measurement files that will be created. |
Default = stats |
dump_stats_xlsx_path |
Path to dump an excel containing statistics for analysis. Relevant only for “MEASURE” mode. |
Default = stats.xlsx |
scale_method |
The method for calculating the scale from the measurement. |
|
measure_exclude |
If this attribute is not defined, the default is |
|