NLP（六十七）BERT模型训练后动态量化（PTDQ）

news/2024/7/7 19:21:45

  本文将会介绍BERT模型训练后动态量化（Post Training Dynamic Quantization，PTDQ）。

量化

  在深度学习中，量化（Quantization）指的是使用更少的bit来存储原本以浮点数存储的tensor，以及使用更少的bit来完成原本以浮点数完成的计算。这么做的好处主要有如下几点：

  • 更少的模型体积，接近4倍的减少
  • 可以更快地计算，由于更少的内存访问和更快的int8计算，可以快2~4倍

  PyTorch中的模型参数默认以FP32精度储存。对于量化后的模型，其部分或者全部的tensor操作会使用int类型来计算，而不是使用量化之前的float类型。当然，量化还需要底层硬件支持，x86 CPU(支持AVX2)、ARM CPU、Google TPU、Nvidia Volta/Turing/Ampere、Qualcomm DSP这些主流硬件都对量化提供了支持。

模型量化示例图片

PTDQ

  PyTorch对量化的支持目前有如下三种方式：

  • Post Training Dynamic Quantization：模型训练完毕后的动态量化
  • Post Training Static Quantization：模型训练完毕后的静态量化
  • QAT (Quantization Aware Training)：模型训练中开启量化

  本文仅介绍Post Training Dynamic Quantization（PTDQ）。
  对训练后的模型权重执行动态量化，将浮点模型转换为动态量化模型，仅对模型权重进行量化，偏置不会量化。默认情况下，仅对Linear和RNN变体量化 (因为这些layer的参数量很大，收益更高)。

torch.quantization.quantize_dynamic(model, qconfig_spec=None, dtype=torch.qint8, mapping=None, inplace=False)

参数解释：

  • model：模型（默认为FP32）
  • qconfig_spec：
  1. 集合：比如： qconfig_spec={nn.LSTM, nn.Linear} 。列出要量化的神经网络模块。
  2. 字典： qconfig_spec = {nn.Linear: default_dynamic_qconfig, nn.LSTM: default_dynamic_qconfig}
  • dtype： float16 或 qint8
  • mapping：就地执行模型转换，原始模块发生变异
  • inplace：将子模块的类型映射到需要替换子模块的相应动态量化版本的类型

例子：

# -*- coding: utf-8 -*-
# 动态量化模型，只量化权重
import torch
from torch import nn


class DemoModel(torch.nn.Module):
    def __init__(self):
        super(DemoModel, self).__init__()
        self.conv = nn.Conv2d(in_channels=1, out_channels=1, kernel_size=1)
        self.relu = nn.ReLU()
        self.fc = torch.nn.Linear(2, 2)

    def forward(self, x):
        x = self.conv(x)
        x = self.relu(x)
        x = self.fc(x)
        return x


if __name__ == "__main__":
    model_fp32 = DemoModel()
    # 创建一个量化的模型实例
    model_int8 = torch.quantization.quantize_dynamic(model=model_fp32,  # 原始模型
                                                     qconfig_spec={torch.nn.Linear},  # 要动态量化的算子
                                                     dtype=torch.qint8)  # 将权重量化为：qint8

    print(model_fp32)
    print(model_int8)

    # 运行模型
    input_fp32 = torch.randn(1, 1, 2, 2)
    output_fp32 = model_fp32(input_fp32)
    print(output_fp32)

    output_int8 = model_int8(input_fp32)
    print(output_int8)

输出结果如下：

DemoModel(
  (conv): Conv2d(1, 1, kernel_size=(1, 1), stride=(1, 1))
  (relu): ReLU()
  (fc): Linear(in_features=2, out_features=2, bias=True)
)
DemoModel(
  (conv): Conv2d(1, 1, kernel_size=(1, 1), stride=(1, 1))
  (relu): ReLU()
  (fc): DynamicQuantizedLinear(in_features=2, out_features=2, dtype=torch.qint8, qscheme=torch.per_tensor_affine)
)
tensor([[[[0.3120, 0.3042],
          [0.3120, 0.3042]]]], grad_fn=<AddBackward0>)
tensor([[[[0.3120, 0.3042],
          [0.3120, 0.3042]]]])

模型量化策略

  当前，由于量化算子的覆盖有限，因此，对于不同的深度学习模型，其量化策略不同，见下表：

模型量化策略原因
LSTM/RNNDynamic Quantization模型吞吐量由权重的计算/内存带宽决定
BERT/TransformerDynamic Quantization模型吞吐量由权重的计算/内存带宽决定
CNNStatic Quantization模型吞吐量由激活函数的内存带宽决定
CNNQuantization Aware Training模型准确率不能由Static Quantization获取的情况

   下面对BERT模型进行训练后动态量化，分析模型在量化前后，推理效果和推理性能的变化。

实验

   我们使用的训练后的模型为中文文本分类模型，其训练过程可以参考文章：NLP（六十六）使用HuggingFace中的Trainer进行BERT模型微调 。
   训练后的BERT模型动态量化实验的设置如下：

  1. base model: bert-base-chinese
  2. CPU info: x86-64, Intel® Core™ i5-10210U CPU @ 1.60GHz
  3. batch size: 1
  4. thread: 1

   具体的实验过程如下：

  • 加载模型及tokenizer
import torch
from transformers import AutoModelForSequenceClassification

MAX_LENGTH = 128
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
checkpoint = f"./sougou_test_trainer_{MAX_LENGTH}/checkpoint-96"
model = AutoModelForSequenceClassification.from_pretrained(checkpoint).to(device)
from transformers import AutoTokenizer, DataCollatorWithPadding

tokenizer = AutoTokenizer.from_pretrained(checkpoint)
  • 测试数据集
import pandas as pd

test_df = pd.read_csv("./data/sougou/test.csv")

test_df.head()
textlabel
0届数比赛时间比赛地点参加国家和地区冠军亚军决赛成绩第一届1956-1957英国11美国丹麦6...0
1商品属性材质软橡胶带加浮雕工艺+合金彩色队徽吊牌规格162mm数量这一系列产品不限量发行图案...0
2今天下午，沈阳金德和长春亚泰队将在五里河相遇。在这两支球队中沈阳籍球员居多，因此这场比赛实际...0
3本报讯中国足协准备好了与特鲁西埃谈判的合同文本，也在北京给他预订好了房间，但特鲁西埃爽约了！...0
4网友点击发表评论祝贺中国队夺得五连冠搜狐体育讯北京时间5月6日，2006年尤伯杯羽毛球赛在日...0
  • 量化前模型的推理时间及评估指标
import numpy as np
import time

s_time = time.time()
true_labels, pred_labels = [], [] 
for i, row in test_df.iterrows():
    row_s_time = time.time()
    true_labels.append(row["label"])
    encoded_text = tokenizer(row['text'], max_length=MAX_LENGTH, truncation=True, padding=True, return_tensors='pt').to(device)
    # print(encoded_text)
    logits = model(**encoded_text)
    label_id = np.argmax(logits[0].detach().cpu().numpy(), axis=1)[0]
    pred_labels.append(label_id)
    print(i, (time.time() - row_s_time)*1000, label_id)

print("avg time: ", (time.time() - s_time) * 1000 / test_df.shape[0])

0 229.3872833251953 0
100 362.0314598083496 1
200 311.16747856140137 2
300 324.13792610168457 3
400 406.9099426269531 4
avg time:  352.44047810332944

from sklearn.metrics import classification_report

print(classification_report(true_labels, pred_labels, digits=4))

              precision    recall  f1-score   support

           0     0.9900    1.0000    0.9950        99
           1     0.9691    0.9495    0.9592        99
           2     0.9900    1.0000    0.9950        99
           3     0.9320    0.9697    0.9505        99
           4     0.9895    0.9495    0.9691        99

    accuracy                         0.9737       495
   macro avg     0.9741    0.9737    0.9737       495
weighted avg     0.9741    0.9737    0.9737       495
  • 设置量化后端
# 模型量化
cpu_device = torch.device("cpu")

torch.backends.quantized.supported_engines

['none', 'onednn', 'x86', 'fbgemm']

torch.backends.quantized.engine = 'x86'
  • 量化后模型的推理时间及评估指标
# 8-bit 量化
quantized_model = torch.quantization.quantize_dynamic(
    model, {torch.nn.Linear}, dtype=torch.qint8
).to(cpu_device)

q_s_time = time.time()
q_true_labels, q_pred_labels = [], [] 

for i, row in test_df.iterrows():
    row_s_time = time.time()
    q_true_labels.append(row["label"])
    encoded_text = tokenizer(row['text'], max_length=MAX_LENGTH, truncation=True, padding=True, return_tensors='pt').to(cpu_device)
    logits = quantized_model(**encoded_text)
    label_id = np.argmax(logits[0].detach().numpy(), axis=1)[0]
    q_pred_labels.append(label_id)
    print(i, (time.time() - row_s_time) * 1000, label_id)
    
print("avg time: ", (time.time() - q_s_time) * 1000 / test_df.shape[0])

0 195.47462463378906 0
100 247.33805656433105 1
200 219.41304206848145 2
300 206.44831657409668 3
400 187.4992847442627 4
avg time:  217.63229466447928

from sklearn.metrics import classification_report

print(classification_report(q_true_labels, q_pred_labels, digits=4))

              precision    recall  f1-score   support

           0     0.9900    1.0000    0.9950        99
           1     0.9688    0.9394    0.9538        99
           2     0.9900    1.0000    0.9950        99
           3     0.9320    0.9697    0.9505        99
           4     0.9896    0.9596    0.9744        99

    accuracy                         0.9737       495
   macro avg     0.9741    0.9737    0.9737       495
weighted avg     0.9741    0.9737    0.9737       495
  • 量化前后模型大小对比
import os

def print_size_of_model(model):
    torch.save(model.state_dict(), "temp.p")
    print("Size (MB): ", os.path.getsize("temp.p")/1e6)
    os.remove("temp.p")

print_size_of_model(model)
print_size_of_model(quantized_model)

Size (MB):  409.155273
Size (MB):  152.627621

  量化后端（Quantization backend）取决于CPU架构，不同计算机的CPU架构不同，因此，默认的动态量化不一定在所有的CPU上都能生效，需根据自己计算机的CPU架构设置好对应的量化后端。另外，不同的量化后端也有些许差异。Linux服务器使用uname -a可查看CPU信息。
  重复上述实验过程，以模型的最大输入长度为变量，取值为128,256,384，每种情况各做3次实验，结果如下：

实验最大长度量化前平均推理时间(ms)量化前weighted F1值量化前平均推理时间(ms)量化前weighted F1值
实验138410660.97976860.9838
实验23841047.60.9899738.10.9879
实验33841020.90.9817714.00.9838
实验1256668.70.9717431.40.9718
实验2256675.10.9717449.90.9718
实验3256656.00.9717446.50.9718
实验1128335.80.9737200.50.9737
实验2128336.50.9737227.20.9737
实验3128352.40.9737217.60.9737

  综上所述，对于训练后的BERT模型（文本分类模型）进行动态量化，其结论如下：

  • 模型推理效果：量化前后基本相同，量化后略有下降
  • 模型推理时间：量化后平均提速约1.52倍

总结

  本文介绍了量化基本概念，PyTorch模型量化方式，以及对BERT模型训练后进行动态量化后在推理效果和推理性能上的实验。
  本文项目已开源至Github项目：https://github.com/percent4/dynamic_quantization_on_bert 。
  本人已开通个人博客网站，网址为：https://percent4.github.io/ ，欢迎大家访问~


http://lihuaxi.xjx100.cn/news/1510024.html

相关文章

AUTOSAR规范与ECU软件开发(实践篇）7.10MCAL模块配置方法及常用接口函数介绍之Base与Resource的配置

AUTOSAR规范与ECU软件开发(实践篇）7.10MCAL模块配置方法及常用接口函数介绍之Base与Resource的配置

目录 1、前言 2 、Base与Resource模块 1、前言 本例程的硬件平台为MPC5744P开发板&#xff0c;主要配置MPC5744P的mcal的每个模块的配置&#xff0c;如要配置NXP的MCU之S32k324的例程请参考&#xff1a; 2 、Base与Resource模块 Base与Resource这两个模块与具体功能无关&…
阅读更多...
Shell自动化日志维护脚本

Shell自动化日志维护脚本

简介&#xff1a; 系统日志对于了解操作系统的运行状况、故障排除和性能分析至关重要。然而&#xff0c;长期积累的日志文件可能变得庞大&#xff0c;影响系统性能。在这篇文章中&#xff0c;我们将介绍一个自动化的解决方案&#xff0c;使用 Bash 脚本来监控和维护系统日志文件…
阅读更多...
Docker 相关操作，及其一键安装Docker脚本

Docker 相关操作，及其一键安装Docker脚本

一、模拟CentOS 7.5上安装Docker&#xff1a; 创建一个CentOS 7.5的虚拟机或使用其他方式准备一个CentOS 7.5的环境。 在CentOS 7.5上执行以下命令&#xff0c;以安装Docker的依赖项&#xff1a; sudo yum install -y yum-utils device-mapper-persistent-data lvm2 添加Doc…
阅读更多...
Spring IOC的理解

Spring IOC的理解

总&#xff1a; 控制反转&#xff08;IOC&#xff09;&#xff1a;理论思想&#xff0c;传统java开发模式&#xff0c;对象是由使用者来进行管理&#xff0c;有了spring后&#xff0c;可以交给spring来帮我们进行管理。依赖注入&#xff08;DI&#xff09;&#xff1a;把对应的…
阅读更多...
文本标注技术方案（NLP标注工具）

文本标注技术方案（NLP标注工具）

Doccano doccano 是一个面向人类的开源文本注释工具。它为文本分类、序列标记和序列到序列任务提供注释功能。您可以创建用于情感分析、命名实体识别、文本摘要等的标记数据。只需创建一个项目&#xff0c;上传数据&#xff0c;然后开始注释。您可以在数小时内构建数据集。 支持…
阅读更多...
目标检测YOLO实战应用案例100讲-道路场景下目标检测与分割模型的压缩研究与实现（续）

目标检测YOLO实战应用案例100讲-道路场景下目标检测与分割模型的压缩研究与实现（续）

目录 道路场景下目标检测与语义分割模型的改进研究 3.1 道路场景数据集分析 3.1.1 Cityscapes数据集
阅读更多...
网络防火墙与入侵检测系统（IDS/IPS）：深入研究现代防火墙和IDS/IPS技术，提供配置和管理建议

网络防火墙与入侵检测系统（IDS/IPS）：深入研究现代防火墙和IDS/IPS技术，提供配置和管理建议

第一章&#xff1a;引言 随着信息技术的飞速发展&#xff0c;网络安全的重要性日益凸显。在这个充满威胁的数字时代&#xff0c;网络防火墙和入侵检测系统&#xff08;IDS/IPS&#xff09;成为保护企业和个人免受网络攻击的关键工具。本文将深入研究现代防火墙和IDS/IPS技术&a…
阅读更多...
pybind11学习

pybind11学习

2023.9.1 参考pybind11官方文档&#xff1a;https://pybind11.readthedocs.io/en/stable/index.html 参考&#xff1a;https://blog.csdn.net/fengbingchun/article/details/123022405 Installing the library 我是在wsl-ubuntu中进行测试&#xff1b;在python虚拟环境中安装…
阅读更多...
最新文章

Copyright @ 2022~2023