1. 介绍
设计模型时需要权衡一些特征，如调整模型层数、RNN参数量，在准确率和performance（如模型尺寸 和/或 model latency或throughput2）之间进行权衡。这样的改变可能会非常浪费时间和计算资源，因为你需要重复迭代训练过程以得到实验结果。Quantization可以让你一个训练好的模型上做推理任务时，在performance和模型准确率之间实现类似的权衡。
它可以使你的模型尺寸大幅下降，latency显著减少，但是模型准确率下降很少。
2. 什么是Dynamic Quantization？
Quantizing一个网络，是对网络本身进行转换，使其权重和/或激活函数使用更低精度的整数表示。这使model size减小，让CPU/GPU上可以用更高的throughput math operations（这句话我没看懂什么意思，总之应该是表示模型运行更快了）。
在从浮点数转换成整型时，你需要将浮点数乘以某一scale factor，将结果round到一个整数上。不同quantization方法的区别就在于选择scale factor的方法。
正如将在本文中描述的，dynamic quantization的核心思想，就是根据运行时观察到的数据范围来动态地（dynamically）决定激活函数的scale factor。这保证了scale factor是经过调整的，可以保留被观察到数据集尽可能多的信息。
模型参数在转换时已知，它们会被提前转换为INT8格式。
quantized model中的计算使用vectorized INT8 instructions执行。数据累积时一般使用INT16或INT32以防溢出。在下一层被量化、或为输出转化为FP32后，这个高精度值就会被scale回INT8。
Dynamic quantization调整参数的过程是相对自由的，这使它很适宜于被添加到production pipelines，作为部署LSTM模型的一个标准环节。
（注意：本文的介绍有所简化）
- 你需要一个小LSTM模型。
- 你用随机的hidden state初始化网络。
- 你在随机输入上测试网络。
- 你要在这个教程中训练网络。
- 你将会看到这个网络的quantized版本比我们一开始的floating point版本更小、运算更快。
- 你会看到这个网络的输出值几乎和FP32网络的输出值相当，但是我们并不保证在真实的训练好的模型上期望的accuracy loss。（我觉得这个应该是说本教程没有证明在真实网络上，准确率、损失函数这些量化评估指标在转变后依然可以保持原水平）
（对这一点的证明，教程中给出了另一个参考资料，我还没看，以后也准备写相应教程的笔记：(beta) Dynamic Quantization on an LSTM Word Language Model — PyTorch Tutorials 1.11.0+cu102 documentation）
3. 代码步骤
- Set Up：定义一个简单的LSTM，导入模块，创建一些随机输入张量。
- Do the Quantization：初始化一个浮点数的模型，并创建一个它的quantized版。
- Look at Model Size：在这一步可以看到模型尺寸有所变小。
- Look at Latency：在这一步运行2个模型，比较模型运行时间（latency）。
- Look at Accuracy：在这一步运行2个模型，比较模型输出。
3.1 Set Up
# import the modules used here in this recipe import torch import torch.quantization import torch.nn as nn import copy import os import time # define a very, very simple LSTM for demonstration purposes # in this case, we are wrapping nn.LSTM, one layer, no pre or post processing # inspired by # https://pytorch.org/tutorials/beginner/nlp/sequence_models_tutorial.html, by Robert Guthrie # and https://pytorch.org/tutorials/advanced/dynamic_quantization_tutorial.html class lstm_for_demonstration(nn.Module): """Elementary Long Short Term Memory style model which simply wraps nn.LSTM Not to be used for anything other than demonstration. """ def __init__(self,in_dim,out_dim,depth): super(lstm_for_demonstration,self).__init__() self.lstm = nn.LSTM(in_dim,out_dim,depth) def forward(self,inputs,hidden): out,hidden = self.lstm(inputs,hidden) return out, hidden torch.manual_seed(29592) # set the seed for reproducibility #shape parameters model_dimension=8 sequence_length=20 batch_size=1 lstm_depth=1 # random data for input inputs = torch.randn(sequence_length,batch_size,model_dimension) # hidden is actually is a tuple of the initial hidden state and the initial cell state hidden = (torch.randn(lstm_depth,batch_size,model_dimension), torch.randn(lstm_depth,batch_size,model_dimension))
3.2 Do the Quantization
在这一部分，我们将运用torch.quantization.quantize_dynamic()函数。
其入参为模型，想要quantize的submodules（如果出现的话），目标datatype，返回一个原模型的quantized版本（nn.Module类）。
# here is our floating point instance float_lstm = lstm_for_demonstration(model_dimension, model_dimension,lstm_depth) # this is the call that does the work quantized_lstm = torch.quantization.quantize_dynamic( float_lstm, {nn.LSTM, nn.Linear}, dtype=torch.qint8 ) # show the changes that were made print('Here is the floating point version of this module:') print(float_lstm) print('') print('and now the quantized version:') print(quantized_lstm)
输出：
Here is the floating point version of this module: lstm_for_demonstration( (lstm): LSTM(8, 8) ) and now the quantized version: lstm_for_demonstration( (lstm): DynamicQuantizedLSTM(8, 8) )
3.3 Look at Model Size
现在我们已经quantize了模型，将FP32的模型参数替换为INT8（和一些被记录的scale factors），这意味着我们减少了75%左右的模型储存空间。在本文所使用的默认值上的减少会小于75%，但如果你增加模型尺寸（如设置model dimension到80），这个压缩程度就会趋近于25%，因为此时模型尺寸受参数值的影响更大。
#临时储存模型，计算储存空间，然后删除 def print_size_of_model(model, label=""): torch.save(model.state_dict(), "temp.p") size=os.path.getsize("temp.p") print("model: ",label,' \t','Size (KB):', size/1e3) os.remove('temp.p') return size # compare the sizes f=print_size_of_model(float_lstm,"fp32") q=print_size_of_model(quantized_lstm,"int8") print("{0:.2f} times smaller".format(f/q))
输出：
model: fp32 Size (KB): 4.051 model: int8 Size (KB): 2.963 1.37 times smaller
可以看到正如本节前文所说，这个压缩程度是大于25%的。
3.4 Look at Latency
quantized模型也会运行更快。这是因为：
- 转移参数花费的时间更少。
- INT8的运算操作更快。
在这个简易版模型上你就能看到速度的提升（这是文档原话，但其实实验结果是原模型运行更快……），在复杂模型上一般会提升更多。但影响latency的原因很多。
原模型：
print("Floating point FP32") %timeit float_lstm.forward(inputs, hidden)
输出：
Floating point FP32 830 µs ± 9.39 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
quantized模型：
print("Quantized INT8") %timeit quantized_lstm.forward(inputs,hidden)
输出：
Quantized INT8 913 µs ± 13.2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
3.5 Look at Accuracy
因为模型是随机初始化而非经过训练的，所以我们就不严格计算准确率的改变程度了（因为没有意义）。但是我们可以迅速、简单看一下quantized网络可以输出跟原网络差不多的结果。
更多分析请参考本文末提到的进阶教程。
计算输出的平均值，经比较后发现差异很小：
# run the float model out1, hidden1 = float_lstm(inputs, hidden) mag1 = torch.mean(abs(out1)).item() print('mean absolute value of output tensor values in the FP32 model is {0:.5f} '.format(mag1)) # run the quantized model out2, hidden2 = quantized_lstm(inputs, hidden) mag2 = torch.mean(abs(out2)).item() print('mean absolute value of output tensor values in the INT8 model is {0:.5f}'.format(mag2)) # compare them mag3 = torch.mean(abs(out1-out2)).item() print('mean absolute value of the difference between the output tensors is {0:.5f} or {1:.2f} percent'.format(mag3,mag3/mag1*100))
输出：
mean absolute value of output tensor values in the FP32 model is 0.12887 mean absolute value of output tensor values in the INT8 model is 0.12912 mean absolute value of the difference between the output tensors is 0.00156 or 1.21 percent
6. 教程中提供的其他参考资料
- (beta) Dynamic Quantization on an LSTM Word Language Model Tutorial：这一篇我已经计划要撰写学习笔记博文
- Quantization API Documentaion
- (beta) Dynamic Quantization on BERT：这一篇我已经计划要撰写学习笔记博文
- Introduction to Quantization on PyTorch | PyTorch
