torch.fx量化resnet18_cifar10

已于 2024-03-30 20:51:44 修改
阅读量283 收藏 5
点赞数 4
文章标签： 深度学习 人工智能
于 2024-03-30 00:33:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/t765833631/article/details/137125571
版权

运行环境

11th Gen Intel® Core™ i7-11370H @ 3.30GHz

从HuggingFace上下载训练好的模型 链接

import timm
model = timm.create_model("resnet18_cifar10", pretrained=True)

加载模型

import torch
from torch import nn
from torchvision.models.resnet import resnet18

model=resnet18(pretrained=True) #加载pytorch官方提供的预训练模型结构
#手动修改网络层维度，与自定义模型结构相同
model.conv1 = nn.Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
model.maxpool = nn.Identity()  # type: ignore
model.fc=nn.Linear(model.fc.in_features,10)
#根据模型结构将模型的state_dict(参数)加载到模型中
#torch.load函数用pickle的反序列化功能将保存的对象文件加载到内存中。这个函数还支持将数据加载到指定的设备上。
#model.load_state_dict函数用于使用反序列化的state_dict加载模型的参数字典。
model.load_state_dict(torch.load("resnet18_cifar10.pth",map_location='cpu'))
model.to(torch.device("cpu"))
model.eval()#设置模型为推理模式

DataLoader加载Cifar10数据集

from torch.utils.data import DataLoader

# 设置mean和scale
transform_test = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])

#下载数据集
train_data = torchvision.datasets.CIFAR10(root='data', train=True, transform=torchvision.transforms.ToTensor(),download=True)
test_data = torchvision.datasets.CIFAR10(root='data', train=False, transform=transform_test,download=True)

# DataLoader加载数据集
train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)

量化校准并量化

# 校准恢复精度
model_to_quantize=copy.deepcopy(model)
prepared_model=prepare_fx(model_to_quantize,qconfig_mapping,example_inputs=torch.randn([1,3,224,224]))
prepared_model.eval()
#量化校准
with torch.inference_mode():
    for inputs,labels in test_dataloader:
        prepared_model(inputs)
quantized_recover_model=convert_fx(prepared_model)
print(f"quantized model {quantized_recover_model.graph.print_tabular()}")

保存量化后的模型:

script_module = torch.jit.trace(quantized_recover_model, example_inputs=torch.randn([1, 3, 224, 224]))
torch.jit.save(script_module, "quant_model.pth")

加载序列化的量化模型并测试模型精度：

quantized_recover_model = torch.jit.load("C:\\Users\\tanfengfeng\\PycharmProjects\\pythonProject1\\quant_model.pth")
# quantized_recover_model.load_state_dict(torch.load("C:\\Users\\tanfengfeng\\PycharmProjects\\pythonProject1\\tmp.pt", map_location='cpu'))
with torch.autograd.profiler.profile(enabled=True, use_cuda=False, record_shapes=False, profile_memory=False) as prof:
    test(quantized_recover_model, test_dataloader, device='cpu')
print(prof.table())

测试模型精度:

def test(model, test_dataloader, device):
    best_acc = 0
    model.eval()
    test_loss = 0
    correct = 0
    total = 0
    test_acc = 0
    with torch.no_grad():#设置禁止计算梯度
        for batch_idx, (inputs, targets) in enumerate(test_dataloader):#从DataLoader获取数据
            inputs, targets = inputs.to(device), targets.to(device)
            outputs = model(inputs)#前向传播
            criterion = nn.CrossEntropyLoss()
            loss = criterion(outputs, targets)#计算交叉熵损失

            test_loss += loss.item()# item（） 获取标量的数值
            _, predicted = outputs.max(1) # 返回第1个维度上的最大的（元素值，索引） predicted为每个样本预测的分类Id
            total += targets.size(0)
            correct += predicted.eq(targets).sum().item()

        test_acc = correct / total
        print('[INFO] Test Accurancy: {:.3f}'.format(test_acc), '\n')

完整代码：

# https://juejin.cn/post/7178317867492835383#heading-7
# https://huggingface.co/edadaltocg/resnet18_cifar10

import os
import copy
import time

import torch
from torch import nn

import torchvision
from torchvision import transforms
from torchvision.models.resnet import resnet18

from torch.quantization.quantize_fx import prepare_fx, convert_fx
from torch.ao.quantization import get_default_qconfig_mapping

from torch.utils.data import DataLoader

def test(model, test_dataloader, device):
    best_acc = 0
    model.eval()
    test_loss = 0
    correct = 0
    total = 0
    test_acc = 0
    with torch.no_grad():  # 设置禁止计算梯度
        for batch_idx, (inputs, targets) in enumerate(test_dataloader):  # 从DataLoader获取数据
            inputs, targets = inputs.to(device), targets.to(device)
            outputs = model(inputs)  # 前向传播
            criterion = nn.CrossEntropyLoss()
            loss = criterion(outputs, targets)  # 计算交叉熵损失

            test_loss += loss.item()  # item（） 获取标量的数值
            _, predicted = outputs.max(1)  # 返回第1个维度上的最大的（元素值，索引） predicted为每个样本预测的分类Id
            total += targets.size(0)
            correct += predicted.eq(targets).sum().item()

        test_acc = correct / total
        print('[INFO] Test Accurancy: {:.3f}'.format(test_acc), '\n')


def print_size_of_model(model):
    torch.save(model.state_dict(), "tmp.pt")
    print(f"The model size:{os.path.getsize('tmp.pt') / 1e6}MB")

model = resnet18(pretrained=True)
# 修改模型
model.conv1 = nn.Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
model.maxpool = nn.Identity()  # type: ignore
model.fc = nn.Linear(model.fc.in_features, 10)
model.load_state_dict(
    torch.load("C:\\Users\\tanfengfeng\\.cache\\torch\\hub\\checkpoints\\resnet18_cifar10.pth", map_location='cpu'))
model.to(torch.device("cpu"))
model.eval()

# 设置mean和scale
transform_test = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])

# 准备数据集
train_data = torchvision.datasets.CIFAR10(root='data', train=True, transform=torchvision.transforms.ToTensor(),download=True)
test_data = torchvision.datasets.CIFAR10(root='data', train=False, transform=transform_test, download=True)

print("训练集的长度:{}".format(len(train_data)))
print("测试集的长度:{}".format(len(test_data)))

# DataLoader加载数据集
train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)

#量化
torch.backends.quantized.engine = 'fbgemm'  # 设置量化后端
qconfig_mapping = get_default_qconfig_mapping("fbgemm")
# 校准量化精度
model_to_quantize = copy.deepcopy(model)
prepared_model = prepare_fx(model_to_quantize, qconfig_mapping, example_inputs=torch.randn([1, 3, 224, 224]))
prepared_model.eval()
with torch.inference_mode():
    for inputs, labels in test_dataloader:
        prepared_model(inputs)

quantized_recover_model = convert_fx(prepared_model)
# print(f"quantized model {quantized_recover_model.graph.print_tabular()}")
script_module = torch.jit.trace(quantized_recover_model, example_inputs=torch.randn([1, 3, 224, 224]))
torch.jit.save(script_module, "quant_model.pth")
# print_size_of_model(prepared_model)
# print_size_of_model(quantized_recover_model)


#测试FP32模型精度和耗时
with torch.autograd.profiler.profile(enabled=True, use_cuda=False, record_shapes=False, profile_memory=False) as prof:
    test(model, test_dataloader, device='cpu')
print(prof.table())


#测试int8模型精度和耗时
quantized_recover_model = torch.jit.load("C:\\Users\\tanfengfeng\\PycharmProjects\\pythonProject1\\quant_model.pth")
with torch.autograd.profiler.profile(enabled=True, use_cuda=False, record_shapes=False, profile_memory=False) as prof:
    test(quantized_recover_model, test_dataloader, device='cpu')
print(prof.table())

运行结果截图：
FP32：
在这里插入图片描述
在这里插入图片描述
量化后：
在这里插入图片描述
在这里插入图片描述

总结

量化后推理时间快了一倍，并且模型精度几乎没有损耗。

conv+bn+relu 融合成conv_relu算子

在这里插入图片描述

conv+bn 融合成 conv

在这里插入图片描述

add + relu 融合成 add_relu

在这里插入图片描述

thetffs
关注
torch.fx量化resnet18-cifar10
03-30
int8量化后的resnet18_cifar10模型文件
ResNet分类器量化
bobchen1017的博客
10-11 361
下面先定义一个直方图校准的int8量化，然后对输入全部进行量化定义模型对模型插入qdq统计qdq节点的range 和 scale做敏感词分析导出一个qdq节点的ptq对模型进行finetune ----> qat。
量化ResNet
weixin_45919003的博客
04-25 635
在量化resnet过程中遇到的一些问题
Pytorch量化(torch.quantization)
hxxjxw的博客
04-22 6678
在深度学习中，量化指的是使用更少的bit来存储原本以浮点数存储的tensor，以及使用更少的bit来完成原本以浮点数完成的计算。这么做的好处主要有如下几点： 更少的模型体积，接近4倍的减少； 可以更快的计算，由于更少的内存访问和更快的int8计算，可以快2~4倍。 一个量化后的模型，其部分或者全部的tensor操作会使用int类型来计算，而不是使用量化之前的float类型。当然，量化还需要底层硬件支持，x86 CPU（支持AVX2）、ARM CPU、Google TPU、Nvi...
pytorch量化
weixin_45919003的博客
04-13 2248
pytorch源码学习记录
torch量化的流程
踟蹰横渡口,彳亍上滩舟。
06-27 2762
量化工作流程 PyTorch 提供了三种量化模型的方法。 训练后动态量化： 这是最简单的量化形式，其中权重被提前量化，而激活在推理过程中被动态量化。 这用于以下情况：模型执行时间主要由从内存中加载权重而不是计算矩阵乘法来决定。 对于小批量的 LSTM 和 Transformer 类型的模型，这是正确的。 只需调用一次 torch.quantization.quantize_dynamic() ，即可将动态量化应用于整个模型。 请参阅量化教程 训练后静态量化：这是最常用的量化形式，其中权重是提前量化的，并且
fb.resnet.torch-master.zip_ResNet_ResNet深度学习_facebook_torch resn
09-20
1. `models`：存放不同变体的ResNet模型结构定义，如ResNet-18、ResNet-34、ResNet-50、ResNet-101和ResNet-152。 2. `train.lua`和`test.lua`：训练和测试模型的脚本，定义了优化器、损失函数、训练和验证循环等。 ...
resnet18-cifar10 模型文件，通过torch.jit.trace保存
03-30
resnet18_cifar10模型， FP32
torch.cuda.is_available（）返回False解决方案
12-21
`torch.cuda.is_available()` 是一个重要的函数，用于检查当前系统是否能够使用CUDA，即NVIDIA的GPU加速库。当这个函数返回 `False` 时，意味着你的程序将无法在GPU上运行，而会退化到使用CPU。以下是一些可能导致 `...
resnet_cifar.rar
08-07
在本压缩包"resnet_cifar.rar"中，包含了使用PyTorch框架训练的ResNet模型，针对CIFAR-10数据集的预训练权重。CIFAR-10是一个广泛用于图像识别任务的小型多类图像数据集，包含10个类别，每个类别有6000张32x32像素的...
int8量化的resnet50在ImageNet数据集上的推断结果
JachinMa的博客
06-02 2317
将resnet50除全连接层外的所有层均量化为8bit。 结果如图： 这是使用1个cpu核心的结果。 这是使用3个cpu核心的结果。 作为对比，这是全精度模型的结果。 1个cpu核心 3个cpu核心 从结果对比可以看出，量化模型的fps较全精度模型提升了1.x倍，而平均延迟则分别减少了30%和50%。 将转换后的IR模型在Ubuntu上使用cpu做了推断，fps结果和DL Workbench一致，延迟因为不会测试就没有测。 除此之外，量化模型和全精度网络的推断结果还有两个很大比较大的差别：量化模型的
ResNet18云空间部署
算能开发者社区是一个为开发者提供信息传播、开发交流、技术分享的交流空间。
08-24 359
转成mlir文件后, 会生成一个 ${model_name}_in_f32.npz 文件, 该文件是模型的输入文件。编译完成后, 会生成名为 ${model_name}_1684x_f32.bmodel 的文件。指定模型定义文件, 比如`.onnx`或`.tflite`或`.prototxt`文件。指定输入的shape, 例如[[1,3,640,640]];如果不指定, 则resize成模。指定输出的名称, 如果不指定, 则用模型的输出;图片每个通道的比值, 默认为1.0,1.0,1.0。
torch.fx 简介与量化
weixin_42638415的博客
01-14 4956
pytroch发布的torch.fx工具包可以说是很好的消除一些动态图和静态图的Gap，可以使得我们对于nn.Module的各种变化操作变得非常简单。 动态图和静态图： 动态意味着程序将按照我们编写命令的顺序进行执行。这种机制将使得调试更加容易，并且也使得我们将大脑中的想法转化为实际代码变得更加容易。而静态则意味着程序在编译执行时将先生成神经网络的结构，然后再执行相应操作。按照动态图和静态图最明显的两个框架就是pytorch和tensorflow两个。 静态图的优势就在...
Pytorch模型量化实践并以ResNet18模型量化为例(附代码)
ljp1919的专栏
08-08 9589
简介Pytorch中的模型量化并以ResNet18为例进行代码实践。
【pytorch 模型量化方法总结】
weixin_42483745的博客
07-10 1044
后端：x86、arm移动嵌入式平台；对应参数：‘fbgemm’ 、 ‘qnnpack’命令行：torch.quantization.get_default_qconfig(‘fbgemm’)1.动态量化代码示例： 适用于 Linear、LSTM、RNN等层；权重直接量化；bias和激活函数 在推理过程中动态量化；2.静态量化示例： 1.静态量化需要在模型起始和结束位置定义quant和dequant接口；2.配置好后端3.融合的层声明；一般是conv+relu；或者是conv+bn+relu；3.准备量化4.
torch.fx极简量化
whaosoft143ai的博客
01-13 598
这些东西本质上是在做一件事情，至少从量化角度上看是这样的，但是到最后不具备通用性，当你看到 pytorch_quanzation 这个工具保存的模型体积根float32一样的时候，就会开始怀疑人生了，这tm是人干的事儿？由于pytorch的自带的 imagnet系列模型，我们没有办法做calibration，我们用小一些的Cifra10, 不需要下载，pytorch自己可以处理，但是这就需要我们自己finetune一下。很多古老的文章，还在用手动插入stub来做量化节点，这就好比在21世纪还在飞鸽传书。
Resnet18实战cifar10（pytorch代码详解）（5）
weixin_45784327的博客
08-22 985
Resnet18实战cifar10（pytorch代码详解），生动解释resnet原理。
【嵌入式AI】pytorch量化训练，TensorRT， Ascend量化部署
qq_41569098的博客
06-30 1034
量化感知训练（Quantization Aware Training ）是在模型中插入伪量化模块（fake_quant module）模拟量化模型在推理过程中进行的舍入（rounding）和钳位（clamping）操作，从而在训练过程中提高模型对量化效应的适应能力，获得更高的量化模型精度。Pytorch 官方从 1.3 版本开始提供量化感知训练 API，只需修改少量代码即可实现量化感知训练。目前 torch.quantization 仍处于 beta 阶段，不保证 API 前向、后向兼容性。
PyTorch模型量化实战与解析
最新发布
Q2625289483的博客
06-13 372
❝ pytorch一般情况下，是将网络中的参数保存成orderedDict形式的，这里的参数其实包含两种，一种是模型中各种module含的参数，即nn.Parameter,我们当然可以在网络中定义其他的nn.Parameter参数，另一种就是buffer,前者每次optim.step会得到更新，而不会更新后者。进行实验，这里实现了对称和非对称量化两种方案。即将量化后的值乘以就得到了反量化的结果，当然这个过程是有损的，如下图所示，橙色线表示的就是量化前的范围，而蓝色线代表量化后的数据范围，注意权重取。
def resnet_34(): # Define the resnet model resnet = torchvision.models.resnet34(pretrained=True) # Update the fully connected layer of resnet with our current target of 10 desired outputs resnet.fc = torch.nn.Linear(resnet.fc.in_features, 10) # Initialize with xavier uniform torch.nn.init.xavier_uniform_(resnet.fc.weight) return resnet
06-07
这是一个使用PyTorch实现的ResNet-34模型，主要包括以下三个步骤： 1. 调用PyTorch内置的ResNet-34模型 ``` resnet = torchvision.models.resnet34(pretrained=True) ``` 2. 更新ResNet-34模型的全连接层，使其输出维度为10（这里假设是10分类问题） ``` resnet.fc = torch.nn.Linear(resnet.fc.in_features, 10) ``` 3. 对全连接层的权重进行Xavier初始化 ``` torch.nn.init.xavier_uniform_(resnet.fc.weight) ``` 最终返回修改后的ResNet-34模型。 需要注意的是，这里使用了预训练的ResNet-34模型（pretrained=True），这意味着模型的所有权重已经在ImageNet数据集上进行了训练。因此，我们可以从预训练模型中学习到更好的特征表示，从而加速模型的训练和提高模型的准确率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值