IC的帆哥 - 神经网络
https://icfgblog.com/index.php/category/NN/
-
智元机器人比赛排坑记录
https://icfgblog.com/index.php/NN/390.html
2025-09-21T19:03:29+08:00
赛事链接
我选择的是Manipulation 赛道,从8月初到9月中的过程中,为了跑通flow,获得更好的训练效果,踩了不少坑,经过官方老师的耐心解答,热心队伍的无私帮助,终于磕磕碰碰完成了初赛。
一、环境准备
Manipulation 赛道是官方提供baseline 模型,需要完成10项任务,每项任务的完成分为1分,总分10分,提交自己的模型,获得更高的分数。十个任务分别如下,提高的模型有两个:UniVLA 和RDT
1.1 推理环境准备
智元的Genie Sim 环境是在NVIDIA ISAAC Sim基础上开发的机器人仿真平台,能够查看机器人在仿真环境中的任务表现。
具体的准备过程在这个链接:
Genie Sim Benchmark
1.2 没有GPU怎么办?
租用云服务器是很好的选择,如果自己购置GPU,一方面无法灵活配置,价格昂贵,另一方面安装环境也容易被折腾。云服务器随时取用,非常方面,我租用的平台是“智星云”,开始测试的时候用的RTX 4090, 可以选择多GPU和CPU 内存,后面训练的时候切换A100,可谓非常灵活。
租用的版本主要分三个阶段:
数据准备及推理阶段:GPU内存不大,选择4090(24G)
try 训练阶段:排查训练过程中的坑,单GPU 选择4090(48G)
冲刺阶段:两卡A100(80G),多batch size 收敛训练
1.3 数据集下载慢怎么办?
大模型训练的另一个特点是数据集非常庞大,一般都要在huggingface上下载,虽然用git 也行,但下载速度慢,且容易卡断。如果你遇到相同的问题,一定要看这篇知乎,加速效果异常好!
使用 HFD 加快 Hugging Face 模型和数据集的下载
仿真数据集将近1T,直接扩容硬盘到了2T。
wget https://hf-mirror.com/hfd/hfd.sh
chmod a+x hfd.sh
echo 'export HF_ENDPOINT=https://hf-mirror.com' >> ~/.bashrc
source ~/.bashrc
./hfd.sh gpt2 --tool aria2c -x 4
./hfd.sh agibot-world/AgiBotWorldChallenge-2025 --tool aria2c -x 4 --include Manipulation-SimData/*
二、模型推理
按Genie Sim Benchmark的流程可以跑起仿真。期间有遇到几个问题
SIM_ASSETS=~/GenieSimAssets ./scripts/start_gui.sh
./scripts/autorun.sh iros_pack_in_the_supermarket infer UniVLA
2.1 仿真画面完全不出来
报错信息:
这是terminal的问题,运行autorun.sh 脚本的时候,会遍历系统已有的terminal,首选是gnome_terminal,但我这边有些问题,调整成“terminator”之后就ok了。
2.2 仿真无法进行,自动退出
还是在auto_run.sh 的脚本,它会通过terminator 运行三个任务:
运行仿真环境的服务平台
运行仿真任务的场景
运行推理任务的大模型
脚本最后有个while 循环,会检测后台的任务,判断是否超时来退出仿真。我这边的仿真加载慢,经常被强制kill,最后索性注释退出机制,就能成功run起来!
三、模型训练
模型训练卡了很久,需要下载额外下载依赖,添加配置。
按此步骤,不用安装Depth-Anything
3.1 没有internvl库
这个库其实包含在仓库的InternVL 文件夹里,需要export 对应的路径
3.2 没有facebookresearch_dinov2_main
需要把Depth-Anything仓库的facebookresearch_dinov2_main 放到latent_action_model 目录下:
3.3 没有dinov2_vitb14_reg4_pretrain.pth 模型
训练过程中需要加载这个权重,但原仓库下没有这个权重。
在hf 里面搜关键字,终于找到同名的模型权重!
3.4 训练脚本问题
README.md展示的只是示例,具体训练的时候需要修改
其中dataset 的结构如下,hf下载的数据集需要先解压,并放一起:
3.5 内存问题
训练到了10%,后续异常退出。此时GPU内存48G,htop查看训练过程中CPU内存的使用量,发现才16G,远远不够!提高CPU 内存能够解决问题。
服务器CPU 内存的选取有限,为了不让cpu 内存爆掉导致训练终止,需要用其他方法提高内存,最有效的是提高swap分区的大小!后期训练的时候,直接把swap 分区提高到了300G,内存自由!
Linux系统swap分区扩容保姆级教程
3.6 训练后的得分反而更低很多
univla 的训练效果和batch size 有很大关系,一般训练的标配都是8卡A100,每张卡80G,bs=8。然后训练5万步左右。
开始训的时候,我只有可怜的单卡,48G,bs=1,根本没法收敛,越训越烂。
训练的调整过程如下:
单卡4090 48G:从baseline开始,先训task8,得到权重,再训task5,再训task9... -> 容易遗忘,无法收敛 -> 0.35
单卡4090 48G:从baseline开始,一起训task 6,8,5,9,3,1,0,2(task 4,7 数据集太大,放弃)-> bs 太小,无法收敛 ->0.60
单卡4090 48G:从baseline开始,减小learning rate,增大grad_accumulation_steps(相当于提高bs,但训练时间会更长)-> 没效果 0.45分
双卡A100,80G:从baseline开始,一起训task 6,8,5,9,3,1,0,2,bs=8,grad_accumulation_steps=8,loss 收敛效果不佳->1.00
双卡A100,80G:从baseline开始,一起训task 6,8,5,9,3,(放弃其他5个任务)bs=8,grad_accumulation_steps=8,loss 收敛效果还行
四、模型提交
4.1 baseline模型提交
早期测试可以先提交官方的baseline模型,确认格式:解压之后直接是以下文件夹。
cd UniVLA
zip -r ../univla_ori.zip .
4.2 训练模型提交
提交之后,训练显示size 不对。原因是训练的时候没有加 --wogripper 参数,但推理默认是开的,导致不匹配。机械臂包含7各自由度+夹爪1个自由度,双臂就有16个自由度,如果去除夹爪,就只有14个自由度。
解决方式有两种:
推理的infer.py 脚本:wogripper 配置为false
训练的finetune.py 脚本:增加wogripper 参数
赛后八卦:
8卡GPU bs=8, UniVLA训练5万步,分数能到2.45左右
8卡GPU bs默认, RDT训练10万步,分数能到2.45左右
UniVLA 模型的训练好坏,和bs 关系很大,越大越好,调大grad_accumulation 可以增大bs,以时间换空间
-
神经网络初始化pytorch
https://icfgblog.com/index.php/NN/281.html
2021-10-20T11:36:17+08:00
pytorch有默认的初始化函数,但如果想自定义超参数的初始值,改如何操作呢?
一、默认初始化函数
可以在pycharm找nn.Conv2d的定义文件,然后搜索‘reset_parameters’就可以看到它的初始化函数,
同理可以查看nn.BatchNorm2d,nn.Linear的初始化函数。
二、如何增加自定义初始化函数?
下面是简单的VGG网络示例
import torch
import torch.nn.functional as F
import troch.nn as nn
class VGG(nn.Module):
def __init__(self):
super(VGG, self).__init__()
self.conv1 = nn.Conv2d(3, 32, 3, 1, 1,bias=False)
self.conv2_1 = nn.Conv2d(32, 64, 3, 1, 1,bias=False)
self.conv2_2 = nn.Conv2d(64, 64, 3, 1, 1,bias=False)
self.conv3_1 = nn.Conv2d(64, 128, 3, 1, 1,bias=False)
self.conv3_2 = nn.Conv2d(128, 128, 3, 1, 1,bias=False)
self.conv3_3 = nn.Conv2d(128, 128, 3, 1, 1,bias=False)
self.fc1 = nn.Linear(2048, 128,bias=False)
self.fc2 = nn.Linear(128, 10,bias=False)
def forward(self, x):
out = F.relu(self.conv1(x))
out = F.max_pool2d(out, 2)
out = F.relu(self.conv2_1(out))
out = F.relu(self.conv2_2(out))
out = F.max_pool2d(out, 2)
out = F.relu(self.conv3_1(out))
out = F.relu(self.conv3_2(out))
out = F.relu(self.conv3_3(out))
out = F.max_pool2d(out, 2)
out = out.view(out.size(0), -1)
out = F.relu(self.fc1(out))
out = self.fc2(out)
return out
#定义初始化函数
def weights_init(m):
if isinstance(m, nn.Conv2d):
nn.init.constant_(m.weight, 0.5)
#nn.init.constant_(m.bias, 0)
#nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
#nn.init.xavier_normal_(m.weight)
elif isinstance(m, nn.Linear):
nn.init.xavier_uniform_(m.weight)
#nn.init.constant_(m.bias,0)
三、如何实施初始化?
net = VGG()
#apply函数会递归地搜索网络内的所有module并把参数表示的函数应用到所有的module上。
net.apply(weights_init)
四、如何查看初始化的权重?
# 显示网络参数字典的key
net.state_dict().keys()
# 输出conv1层卷积权重
net.state_dict()['conv1.weight']
-
rk3399pro部署unet
https://icfgblog.com/index.php/NN/261.html
2021-09-05T20:03:53+08:00
最近参与一个项目,需要利用unet做焊点检测,unet最终要部署在Rockchip的rk3399pro嵌入式系统里,该系统内部有神经网路加速器,但需要先转成.rknn的格式。
RK3399Pro NPU Manual提供了入门指导,里面的RKNN toolkit 包含了样例和转换工具。我的unet版本是参考github头像匹配的pytorch版本。
一、出师不利
样例提供了torchvision上resnet_18的python版本,能够成功转成rknn格式,代码如下:
import numpy as np
import cv2
from rknn.api import RKNN
import torchvision.models as models
import torch
if __name__ == '__main__':
net = models.resnet_18(pretrained=True)
net.eval()
trace_model = torch.jit.trace(net, torch.Tensor(1, 3, 224, 224))
trace_model.save('./resnet_18.pt')
model = './resnet_18.pt'
input_size_list = [[3,224,224]]
# Create RKNN object
rknn = RKNN()
# pre-process config
print('--> config model')
rknn.config(channel_mean_value='123.675 116.28 103.53 58.395', reorder_channel='0 1 2')
print('done')
# Load pytorch model
print('--> Loading model')
ret = rknn.load_pytorch(model=model, input_size_list=input_size_list)
if ret != 0:
print('Load pytorch model failed!')
exit(ret)
print('done')
# Build model
print('--> Building model')
ret = rknn.build(do_quantization=False, dataset='./dataset.txt')
if ret != 0:
print('Build pytorch failed!')
exit(ret)
print('done')
# Export rknn model
print('--> Export RKNN model')
ret = rknn.export_rknn('./resnet_18.rknn')
if ret != 0:
print('Export resnet_18.rknn failed!')
exit(ret)
print('done')
这里有个关键函数,torch.jit.trace,JIT表示Just In Time Compilation,即时编译。它是Python和C++的桥梁,我们可以使用python训练模型,然后通过JIT将模型转为与语言无关的静态图,供C++调用,能非常方便得部署到树莓派、IOS、Android等设备。
静态图大概长这样:
我一开始先想部署自己训练的VGG模型,网络尽量接近torchvision_models的样例,定义如下:
import torch.nn as nn
import torch
class VGG(nn.Module):
def __init__(self):
super(VGG, self).__init__()
self.conv1 = nn.Conv2d(3, 32, 3, 1, 1,bias=False)
self.relu = nn.ReLU(inplace=True)
self.conv2_1 = nn.Conv2d(32, 64, 3, 1, 1,bias=False)
self.max_pool2d = nn.MaxPool2d(kernel_size=2,stride=2)
self.conv2_2 = nn.Conv2d(64, 64, 3, 1, 1,bias=False)
self.conv3_1 = nn.Conv2d(64, 128, 3, 1, 1,bias=False)
self.conv3_2 = nn.Conv2d(128, 128, 3, 1, 1,bias=False)
self.conv3_3 = nn.Conv2d(128, 128, 3, 1, 1,bias=False)
self.fc1 = nn.Linear(2048, 128,bias=False)
self.fc2 = nn.Linear(128, 10,bias=False)
def forward(self, x):
out = self.relu(self.conv1(x))
out = self.max_pool2d(out)
out = self.relu(self.conv2_1(out))
out = self.relu(self.conv2_2(out))
out = self.max_pool2d(out)
out = self.relu(self.conv3_1(out))
out = self.relu(self.conv3_2(out))
out = self.relu(self.conv3_3(out))
out = self.max_pool2d(out)
out = torch.flatten(out,1)
out = self.relu(self.fc1(out))
out = self.fc2(out)
return out
结果奇怪的是,当运行到ret = rknn.load_pytorch(model=model, input_size_list=input_size_list),一直报错:
AttrubuteError:'NoneType' object has no attribute 'get_input_layers'
rknn.load_python函数是以动态库的方式给的,pycharm debug模式看不到源码,产看静态图,也找不到input_layers这种信息,为之奈何?
竟然官网的样例可以跑通,那一定是模型定义的问题,因此反复比较我的VGG模型和torchvision models上alexnet的区别,终于发现了,不同,虽然有点不理解,但最终还是跑通了:
官网forward函数添加了输入输出类型的定义,torch.Tensor!?这还用定义?这不明摆的吗,真是服了。
二、大Boss
跑通VGG,说明卷积、下采样等函数是支持的,Unet与之相比,只增加了两点:
跨层的拼接:torch.cat([x2,x1],dim=1)
上采样函数:nn.Upsample()
unet模型定义如下:
import torch
import torch.nn as nn
class DoubleConv(nn.Module):
"""(convolution => [BN] => ReLU) * 2"""
def __init__(self, in_channels, out_channels):
super().__init__()
self.double_conv = nn.Sequential(
nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1),
nn.BatchNorm2d(out_channels),
nn.ReLU(inplace=True),
nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1),
nn.BatchNorm2d(out_channels),
nn.ReLU(inplace=True)
)
def forward(self, x:torch.Tensor)->torch.Tensor:
return self.double_conv(x)
class Down(nn.Module):
"""Downscaling with maxpool then double conv"""
def __init__(self, in_channels, out_channels):
super().__init__()
self.maxpool_conv = nn.Sequential(
nn.MaxPool2d(2),
DoubleConv(in_channels, out_channels)
)
def forward(self, x:torch.Tensor)->torch.Tensor:
return self.maxpool_conv(x)
class Up(nn.Module):
"""Upscaling then double conv"""
def __init__(self, in_channels, out_channels, bilinear=True):
super().__init__()
self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
self.conv = DoubleConv(in_channels, out_channels)
#def forward(self, x1:torch.Tensor, x2:torch.Tensor)->torch.Tensor:
def forward(self, x: torch.Tensor) -> torch.Tensor:
x = self.up(x)
return self.conv(x)
class OutConv(nn.Module):
def __init__(self, in_channels, out_channels):
super(OutConv, self).__init__()
self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=1)
def forward(self, x:torch.Tensor)->torch.Tensor:
return self.conv(x)
CHANNEL = 64
class UNet(nn.Module):
def __init__(self, n_channels, n_classes, bilinear=True):
super(UNet, self).__init__()
self.n_channels = n_channels
self.n_classes = n_classes
self.bilinear = bilinear
self.inc = DoubleConv(n_channels, CHANNEL)
self.down1 = Down(CHANNEL, CHANNEL * 2)
self.down2 = Down(CHANNEL * 2, CHANNEL * 4)
self.down3 = Down(CHANNEL * 4, CHANNEL * 8)
self.down4 = Down(CHANNEL * 8, CHANNEL * 8)
self.up1 = Up(CHANNEL * 16, CHANNEL * 4, bilinear)
self.up2 = Up(CHANNEL * 8, CHANNEL * 2, bilinear)
self.up3 = Up(CHANNEL * 4, CHANNEL, bilinear)
self.up4 = Up(CHANNEL * 2, CHANNEL, bilinear)
self.outc = OutConv(CHANNEL, n_classes)
def forward(self, x):
x1 = self.inc(x)
x2 = self.down1(x1)
x3 = self.down2(x2)
x4 = self.down3(x3)
x5 = self.down4(x4)
x = self.up1(x5, x4)
x = self.up2(x, x3)
x = self.up3(x, x2)
x = self.up4(x, x1)
logits = self.outc(x)
return logits
跨层拼接的其实可以参考resnet_18,将原来unet合并的up层展开为上采样+双层卷积,不是硬伤。
难点就在上采样函数,单独提取出来,转换上采样函数,一直报这样的错误:
int() argument must be a string , a bytes-like object or a number, not 'NoneType'
这是啥玩意,pycharm在debug模式下,终于找到torch.Upsample()最后调用的函数torch._C._nn.upsample_bilinear2d()
它会经过一系列判断,获得输入图的维度dim和尺寸信息,最后调用这个内嵌函数。然而,获取输出图像大小时,它调用了input.size()函数,这是报错的关键,静态图怎么要调用这个函数呢?输入确定的情况下,这个大小应该也是确定的吧,直接换成确定大小就行。
知道症结之后,针对跨层拼接和上采样,对模型稍加修改(输入特征图定为544x544):
删除了Up 模块,拆分进forward
上采样函数直接用torch._C._nn.upsample_bilinear2d替换
上采样的输出尺寸直接给固定值
""" Full assembly of the parts to form the complete network """
import torch
import torch.nn as nn
class DoubleConv(nn.Module):
"""(convolution => [BN] => ReLU) * 2"""
def __init__(self, in_channels, out_channels):
super().__init__()
self.double_conv = nn.Sequential(
nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1),
nn.BatchNorm2d(out_channels),
nn.ReLU(inplace=True),
nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1),
nn.BatchNorm2d(out_channels),
nn.ReLU(inplace=True)
)
def forward(self, x:torch.Tensor)->torch.Tensor:
return self.double_conv(x)
class Down(nn.Module):
"""Downscaling with maxpool then double conv"""
def __init__(self, in_channels, out_channels):
super().__init__()
self.maxpool_conv = nn.Sequential(
nn.MaxPool2d(2),
DoubleConv(in_channels, out_channels)
)
def forward(self, x:torch.Tensor)->torch.Tensor:
return self.maxpool_conv(x)
class OutConv(nn.Module):
def __init__(self, in_channels, out_channels):
super(OutConv, self).__init__()
self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=1)
def forward(self, x:torch.Tensor)->torch.Tensor:
return self.conv(x)
CHANNEL = 64
INPUT_SIZE = 544
class UNet(nn.Module):
def __init__(self, n_channels, n_classes, bilinear=True):
super(UNet, self).__init__()
self.n_channels = n_channels
self.n_classes = n_classes
self.bilinear = bilinear
self.inc = DoubleConv(n_channels, CHANNEL)
self.down1 = Down(CHANNEL, CHANNEL * 2)
self.down2 = Down(CHANNEL * 2, CHANNEL * 4)
self.down3 = Down(CHANNEL * 4, CHANNEL * 8)
self.down4 = Down(CHANNEL * 8, CHANNEL * 8)
self.conv1 = DoubleConv(CHANNEL * 16, CHANNEL * 4)
self.conv2 = DoubleConv(CHANNEL * 8, CHANNEL * 2)
self.conv3 = DoubleConv(CHANNEL * 4, CHANNEL)
self.conv4 = DoubleConv(CHANNEL * 2, CHANNEL)
self.outc = OutConv(CHANNEL, n_classes)
def forward(self, x:torch.Tensor)->torch.Tensor:
x1 = self.inc(x)
x2 = self.down1(x1)
x3 = self.down2(x2)
x4 = self.down3(x3)
x = self.down4(x4)
x = torch._C._nn.upsample_bilinear2d(x, [INPUT_SIZE//8, INPUT_SIZE//8], True)
x = self.conv1(torch.cat([x4,x],dim=1))
x = torch._C._nn.upsample_bilinear2d(x, [INPUT_SIZE//4, INPUT_SIZE//4], True)
x = self.conv2(torch.cat([x3,x],dim=1))
x = torch._C._nn.upsample_bilinear2d(x, [INPUT_SIZE // 2, INPUT_SIZE // 2], True)
x = self.conv3(torch.cat([x2,x],dim=1))
x = torch._C._nn.upsample_bilinear2d(x, [INPUT_SIZE , INPUT_SIZE ], True)
x = self.conv4(torch.cat([x1,x],dim=1))
x = self.outc(x)
return x
这样就可以快乐的完成模型转换了!
-
炼丹术——可变学习率训练
https://icfgblog.com/index.php/NN/235.html
2021-06-29T09:10:00+08:00
学习率对网络训练的效果影响很大,一般来看,越到后面,学习率要越小,手动可以调节,但可变学习率会更方便。还有一种更骚的操作是warm up学习,学习率早期先增大预热,再减小。
一、不变学习率
设定学习率为0.01,训练30个epoch,batch_size=128。发现15个epoch之后训练变缓,因此可以在次改变学习率。最终的训练集86.1%,测试集集83.3%
#############1. 数据准备
import torch
import torch.nn as nn
import torch.nn.functional as F
from torchvision import transforms,datasets
datapath = '/home/Dataset/cifar10_data'
train_transform=transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
test_transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])
train_data= datasets.CIFAR10(root=datapath,train = True,transform = train_transform)
test_data = datasets.CIFAR10(root=datapath,train = False,transform =test_transform)
###############2.模型准备
class VGG(nn.Module):
def __init__(self):
super(VGG, self).__init__()
self.conv1 = nn.Conv2d(3, 32, 3, 1, 1,bias=False)
self.conv2_1 = nn.Conv2d(32, 64, 3, 1, 1,bias=False)
self.conv2_2 = nn.Conv2d(64, 64, 3, 1, 1,bias=False)
self.conv3_1 = nn.Conv2d(64, 128, 3, 1, 1,bias=False)
self.conv3_2 = nn.Conv2d(128, 128, 3, 1, 1,bias=False)
self.conv3_3 = nn.Conv2d(128, 128, 3, 1, 1,bias=False)
self.fc1 = nn.Linear(2048, 128,bias=False)
self.fc2 = nn.Linear(128, 10,bias=False)
def forward(self, x):
out = F.relu(self.conv1(x))
out = F.max_pool2d(out, 2)
out = F.relu(self.conv2_1(out))
out = F.relu(self.conv2_2(out))
out = F.max_pool2d(out, 2)
out = F.relu(self.conv3_1(out))
out = F.relu(self.conv3_2(out))
out = F.relu(self.conv3_3(out))
out = F.max_pool2d(out, 2)
out = out.view(out.size(0), -1)
out = F.relu(self.fc1(out))
out = self.fc2(out)
return out
net = VGG()
device = 'cuda' if torch.cuda.is_available() else 'cpu'
net = net.to(device)
from torchsummary import summary
summary(net,(3,32,32))
##############3.参数设置
epochs = 30
lr = 0.01
optimizer = torch.optim.SGD(net.parameters(), lr=lr, momentum=0.9, weight_decay=5e-4)
batch_size = 128
train_loader = torch.utils.data.DataLoader(train_data,batch_size=batch_size,shuffle=True,drop_last=True)
test_loader = torch.utils.data.DataLoader(test_data,batch_size=batch_size,shuffle=False,drop_last=False)
#################### 4.测试函数
def test():
net.eval()
test_loss = 0
correct = 0
total = 0
with torch.no_grad():
for batch_idx, (inputs, targets) in enumerate(test_loader):
inputs, targets = inputs.to(device), targets.to(device)
outputs = net(inputs)
loss = criterion(outputs, targets)
test_loss += loss.item()
_, predicted = outputs.max(1)
total += targets.size(0)
correct += predicted.eq(targets).sum().item()
#print('[Test] Loss: %.3f | Acc: %.3f%% (%d/%d) lr=%.4f' % (test_loss/(len(test_loader.dataset)/100), 100.*correct/total, correct, total,scheduler_warmup.get_lr()[0]))
print('[Test] Loss: %.3f | Acc: %.3f%% (%d/%d) lr=%.4f' % (test_loss/(len(test_loader.dataset)/100), 100.*correct/total, correct, total,lr))
####################5. 训练
net.train()
## Loss and optimizer
criterion = nn.CrossEntropyLoss()
best_acc =0
for epoch in range(epochs):
train_loss = 0
correct = 0
total = 0
print('epoch %d:'%(epoch),end="")
for batch_idx, (inputs, targets) in enumerate(train_loader):
inputs, targets = inputs.to(device), targets.to(device)
optimizer.zero_grad()
outputs = net(inputs)
loss = criterion(outputs, targets)
loss.backward()
optimizer.step()
train_loss += loss.item()
_, predicted = outputs.max(1)
total += targets.size(0)
correct += predicted.eq(targets).sum().item()
print('[Train] Loss: %.3f | Acc: %.3f%% (%d/%d)'% (train_loss/(batch_idx+1), 100.*correct/total, correct, total),end="")
test()
二、学习率衰减
调整学习率需要导入'lr_scheduler'的包,调整选项,比如StepLR,ExpontialLR,MultiStepLR等,详情见链接。有实验表明,离散变化的学习率足以表现良好,首先用StepLR,需要修改三个地方:
1.参数设置部分
epochs = 30
# a.导入包
from torch.optim import lr_scheduler
lr = 0.01
optimizer = torch.optim.SGD(net.parameters(), lr=lr, momentum=0.9, weight_decay=5e-4)
#b.每16个epoch之后,lr变为原来的0.2
scheduler1 = lr_scheduler.StepLR(optimizer,step_size=16,gamma=0.2)
#scheduler1 = lr_scheduler.ExponentialLR(optimizer, gamma=0.95) # 每个epoch,lr变为原来的0.95
#scheduler1 = lr_scheduler.MultistepLR(optimizer,milestones=[10,20],gamma=0.5)# 10epoch后变为原来0.5,20 epoch后又衰减0.5
batch_size = 128
train_loader = torch.utils.data.DataLoader(train_data,batch_size=batch_size,shuffle=True,drop_last=True)
test_loader = torch.utils.data.DataLoader(test_data,batch_size=batch_size,shuffle=False,drop_last=False)
测试集输出
# c.通过scheduler1.get_lr()[0])查看当前学习率
print('[Test] Loss: %.3f | Acc: %.3f%% (%d/%d) lr=%.4f' % (test_loss/(len(test_loader.dataset)/100), 100.*correct/total, correct, total,scheduler1.get_lr()[0]))
#print('[Test] Loss: %.3f | Acc: %.3f%% (%d/%d) lr=%.4f' % (test_loss/(len(test_loader.dataset)/100), 100.*correct/total, correct, total,lr))
训练集更新
print('[Train] Loss: %.3f | Acc: %.3f%% (%d/%d)'% (train_loss/(batch_idx+1), 100.*correct/total, correct, total),end="")
test()
#d.调整学习率
scheduler1.step()
这是lr=0.01,scheduler1 = lr_scheduler.StepLR(optimizer,step_size=16,gamma=0.2)的结果,可见16个epoch减小学习率后,准确率从77% 跳到81%,再缓慢增加。
这是lr=0.02,scheduler1 = lr_scheduler.MultistepLR(optimizer,milestones=[10,20],gamma=0.5),可见第10、20epcoch处有2%的准确率跳变。
这是lr=0.04,scheduler1 = lr_scheduler.ExponentialLR(optimizer,gamma=0.885),30epoch 之后lr降为0.001。可见准确率增长相对稳定,最终到85%。
三、warmup学习
warmup 是学习率先快速增大,然后按之前设置的方式衰减,说明和用法在这,先安装warmup包pip install warmup-scheduler,然后也是修改三个地方:
参数设置
epochs = 30
from torch.optim import lr_scheduler
#a.导入warmup包
from warmup_scheduler import GradualWarmupScheduler
lr = 0.001
optimizer = torch.optim.SGD(net.parameters(), lr=lr, momentum=0.9, weight_decay=5e-4)
#scheduler1 = lr_scheduler.StepLR(optimizer,step_size=10,gamma=0.2)
#scheduler1 = lr_scheduler.MultiStepLR(optimizer,milestones=[5,10,15,20,25],gamma=0.5)
#scheduler1 = lr_scheduler.ExponentialLR(optimizer, gamma=0.885)
#b.前5个epoch,从0.001增加到0.04,之后按scheduler1变化lr
scheduler_warmup = GradualWarmupScheduler(optimizer, multiplier=40, total_epoch=5, after_scheduler=scheduler1)
batch_size = 128
train_loader = torch.utils.data.DataLoader(train_data,batch_size=batch_size,shuffle=True,drop_last=True)
test_loader = torch.utils.data.DataLoader(test_data,batch_size=batch_size,shuffle=False,drop_last=False)
测试集输出
# c.通过scheduler_warmup.get_lr()[0])查看当前学习率
print('[Test] Loss: %.3f | Acc: %.3f%% (%d/%d) lr=%.4f' % (test_loss/(len(test_loader.dataset)/100), 100.*correct/total, correct, total,scheduler_warmup.get_lr()[0]))
#print('[Test] Loss: %.3f | Acc: %.3f%% (%d/%d) lr=%.4f' % (test_loss/(len(test_loader.dataset)/100), 100.*correct/total, correct, total,lr))
训练集更新
这下将更新放在前面的位置
net.train()
## Loss and optimizer
criterion = nn.CrossEntropyLoss()
best_acc =0
for epoch in range(epochs):
#d.调整学习率
scheduler_warmup.step()
train_loss = 0
correct = 0
total = 0
这是先warmup到0.4,再每10epoch缩小为原来的0.2。
这是先warmup到0.4,在[5,10,15,20,25]的epoch节点上,缩小0.5。
这是先warmup到0.4,每个epoch变为原来的0.885。
四、小结
简单总结了一下上面的结果,调整学习率确实可以提升训练的效果,但要调好也不简单,比如batch_size,设为256时效果欠佳;比如起始学习率,0.01显然太小了。
最后附上代码:vgg_cifar10_lr_test.zip
-
tensorpack——Dorefa-alexnet(二)
https://icfgblog.com/index.php/software/211.html
2021-05-11T21:14:00+08:00
上次跑通的是Dorefa样例下的svhn-digit-dorefa.py代码,这次准备跑alexnet-dorefa.py,其中碰到了无数的bug,折腾了好几天,终于跑通了!这里只挑选其中几个我花时间最多的bug。
一、数据集路径
虽然官方代码有描述数据集路径,但对于脑残的我,还是不太理解,还是上图吧:
代码默认的目录是~/tensorpack_data/数据集,跑alexnet-dorefa.py的--data路径就是:/root/.keras/tensorpack_data/imagenet/
二、cuda环境错误
按如下代码运行:
python alexnet-dorefa.py --data /root/.keras/tensorpack_data/imagenet/ --dorefa 1,2,6 --gpu 0,1
出现Registered devices: [CPU, XLA_CPU, XLA_GPU]错误,感觉和硬件有关,参考这篇文章,说单GPU训练的时候是可以的,多GPU训练会碰到,于是为了先跑通,将--gpu 0,1改为--gpu 0。结果确实通过了,然后有了新的错误:
Default MaxPoolingOp only supports NHWC on device type CPU
搜了好久,才在tensorpack的论坛上找到原因,原来确实是GPU的问题,可以通过如下代码验证:
from tensorflow.python.client import device_lib
print(device_lib.list_local_devices())
结果确实发现少了库,报错是确实动态库:
libcublas.so.10.0: cannot open shared object file: No such file or directory
原来我的tensorflow是1.14.0版本,需要cuda10.0版本,对应的cudnn7.4.2版本。一开始还想上官网装cuda,又会是繁琐的工程,没想到可以借助conda快速配置环境:
conda install cudatoolkit=10.0
conda install cudnn=7.4
三、总结
神经网络快把我变神经病了,配置环境花了那么多时间!看似简简单单的几条命令,背后却是满满的辛酸泪。。。
python,tensorflow,cuda,cudnn版本官方对照
这下终于可以运行了:
python alexnet-dorefa.py --data /root/.keras/tensorpack_data/imagenet/ --dorefa 1,2,6 --gpu 0,1
nvidia-smi -L #可以查看可以调用GPU的编号
上图纪念一番:
-
非均匀量化
https://icfgblog.com/index.php/NN/186.html
2021-04-17T17:29:00+08:00
一、为什么需要非均匀量化?
tensorflow,pytorch 等框架下也有量化操作,通常是为了减少权重存储空间,有利于部署移动端。但是基于数字电路的量化只能是均匀的,那么为什么还要研究非均匀量化呢?
忆阻器的电导权重是模拟量,本身具备非均匀量化的可能性,而且忆阻器电导的中间值比较不稳定,均匀量化的时候很难精确。
神经网络的权重本身是非均匀分布的,在密集的地方多取点,稀疏的地方少取点,量化后的误差会更小。
二、如何确定非均匀量化点?
选取的量化点有一个中心思想:它们最接近原始的分布。正好,数学上有个“反变换采样定理”:
假设$U~(0,1)$均匀分布,Y为任意随机变量,$F_Y(y)$为Y的分布,$F^{-1}_Y(y)$为其反函数,则$Z=F_Y^{-1}(U)$与Y同分布。
Inverse transform sampling - Wikipedia
上面的公式很抽象,直接看左图吧。首先想个问题:如果只有一个(0,1)区间均匀随机数发生器,该如何通过变换,生成高斯分布?
我们可以求出高斯分布的分布函数,如中间的曲线,然后每产生(0,1)的随机数,作为纵坐标,确定对应的横坐标,即为高斯随机数。采样5万次之后,会有左图下边的分布。这样就通过分布函数,建立了均匀分布和任意分布的一一映射关系。
接下来的问题是,对任意分布做量化,使其最接近原始分布。我们可以求出统计出分布函数,再映射到均匀分布,之后对均匀分布做量化,最后将量化的结果反映射到原分布,即可确定非均匀量化点。
三、MNIST集量化结果
网络为两层卷积,分别8、12个通道,无bias;一层全连接,无bias。
非均匀量化
均匀量化
简单量化
四、Cifar10 量化结果
网络为两卷积,分别32、64个通道,无bias;一层全连接,无bias。
非均匀量化
均匀量化
简单量化
五、结论及后续
上述结果容易看出,非均匀量化在level数更低的时候有更强的鲁棒性,确实效果会好一些。
但老师说4level量化之后精度还是掉很多,二值网络都可以到95%的精度。我确实惊呆了,怎么做到的!
接下来的任务是复现BNN网络,看看二值网络到底如何训练和推理;然后学习LLoyd在脉冲调制中最小二乘法量化方案。
测试程序
-
CNN训练MNIST数据集tenflow2(下)
https://icfgblog.com/index.php/NN/169.html
2021-03-26T09:24:00+08:00
接下来利用tflite做量化,其实中间的数据流到底有没量化,我也不清楚。。。
一、数据准备
# 1.数据准备
import tensorflow as tf
import numpy as np
mnist = tf.keras.datasets.mnist
img_rows,img_cols = 28,28
(x_train_, y_train_), (x_test_, y_test_) = mnist.load_data()
x_train = x_train_.reshape(x_train_.shape[0],img_rows,img_cols,1)
x_test = x_test_.reshape(x_test_.shape[0],img_rows,img_cols,1)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train = x_train / 256
x_test = x_test / 256
y_train_onehot = tf.keras.utils.to_categorical(y_train_)
y_test_onehot = tf.keras.utils.to_categorical(y_test_)
二、初始模型导入
model = tf.keras.Sequential()
model = tf.keras.models.load_model('models/mnist_tf2_fw.h5')
score = model.evaluate(x_test, y_test_onehot, verbose=0)
print('Test accuracy:', "{:.5f}".format(score[1]))
三、量化模型导入
interpreter= tf.lite.Interpreter(model_path="models/tflite_tf2_8.tflite")
#interpreter= tf.lite.Interpreter(model_path="models/tflite_tf2_dy.tflite")
#interpreter= tf.lite.Interpreter(model_path="models/tflite_tf2_16.tflite")
#interpreter= tf.lite.Interpreter(model_path="models/tflite_tf2_32.tflite")
interpreter.allocate_tensors()
input_details=interpreter.get_input_details()
output_details=interpreter.get_output_details()
#print(input_details)
#print(output_details)
y_lebal=y_test_onehot.argmax(1)
# 量化模型推理
pre = []
# tflite针对安卓端运用,每次只能推理一个数据
for i in range (len(x_test)):
# .astpe 非常重要,找了很久才解决这个bug
x_test1 = x_test[i].reshape(1,28,28,1).astype(np.float32)
interpreter.set_tensor(input_details[0]['index'],x_test1)
interpreter.invoke()
output_data = interpreter.get_tensor(output_details[0]['index'])
pre.append(output_data.argmax())
temp = (pre==y_lebal)
acc=sum(temp)/10000
print(acc)
32bit
16bit
8bit
默认
98.500
98.500
98.440
98.440
这结果似乎和权重量化的差不多。数据流量化确实不太容易,需要更加底层、细粒度的操作。只有rram的训练有可能是4bit和8bit的混合,所以低精度数据流的训练还是挺重要的。
后期计划,做低比特、数据流量化的调用,看看别人的工作,为rram高性能计算打下理论基础。
github 代码
-
CNN训练MNIST数据集tenflow2(中)
https://icfgblog.com/index.php/NN/166.html
2021-03-26T08:38:00+08:00
紧接上文(上),我们已经做好了训练,分别保存了32bit、16bit、8bit的量化模型。本篇的工作是加载模型,查看增加噪声、权重量化时的精度变化。数据流量化的结果将在下篇介绍。
一、加载数据集
# 1. 加载数据集
import tensorflow as tf
import numpy as np
minst = tf.keras.datasets.mnist
img_rows,img_cols = 28,28
(x_train, y_train), (x_test, y_test) = minst.load_data()
x_train = x_train.reshape(x_train.shape[0],img_rows,img_cols,1)
x_test = x_test.reshape(x_test.shape[0],img_rows,img_cols,1)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train = x_train / 255
x_test = x_test / 255
y_train_onehot = tf.keras.utils.to_categorical(y_train)
y_test_onehot = tf.keras.utils.to_categorical(y_test)
二、加载模型和权重,测试准确率
# 2. 加载模型和权重,测试准确率
model = tf.keras.Sequential()
model = tf.keras.models.load_model('models/mnist_tf2_fw.h5')
score = model.evaluate(x_test, y_test_onehot, verbose=0)
print('Test accuracy:', "{:.5f}".format(score[1]))
三、增加噪声,测试准确率
model = tf.keras.models.load_model('models/mnist_tf2_fw.h5')
# 这里0,2,5层分别表示conv1,conv2,fc层的权重
for i in [0,2,5]:
# 通过get_weights 和setweights修改权重
temp = model.layers[i].get_weights()[0]
# 0.15表征噪声的标准差
temp = temp + np.random.rand(*temp.shape)*0.15
model.layers[i].set_weights([temp])
score = model.evaluate(x_test, y_test_onehot, verbose=0)
print('Test accuracy:', "{:.5f}".format(score[1]))
四、权重量化,测试准确率
# 8bit量化
bit = 8
model = tf.keras.models.load_model('models/mnist_tf2_fw.h5')
# 这里0,2,5层分别表示conv1,conv2,fc层的权重
for i in [0,2,5]:
temp = model.layers[i].get_weights()[0]
temp = np.rint(temp * np.power(2,bit))/np.power(2,bit)
model.layers[i].set_weights([temp])
score = model.evaluate(x_test, y_test_onehot, verbose=0)
print('Test accuracy:', "{:.5f}".format(score[1]))
统计结果如下:
噪声标准差
0
0.04
0.06
0.08
0.09
0.10
0.16
准确率
98.500
96.870
92.590
87.510
78.590
70.180
52.800
量化精度
32bit
16bit
8bit
4bit
3bit
2bit
1bit
准确率
98.500
98.500
98.490
98.410
97.380
89.400
66.250
特别说明的是:这里只是对权重做量化,推理计算过程中的数据还是32bit的浮点数,所以结果上看,3bit量化的精度下降不多,只有约1%。
有意思的一点是:3bit量化的准确率和0.04噪声接近;2bit量化准确率和0.08噪声相近,1bit量化的准确率和0.16的噪声相当。
分析原因:3bit量化相当于最小精度是0.125,可以将其等效为$3\sigma$的偏差,求得标准差为0.041,即为0.04的噪声。
github 代码
-
CNN训练MNIST数据集tenflow2(上)
https://icfgblog.com/index.php/NN/165.html
2021-03-25T22:06:00+08:00
背景
还是那片nature的文章Fully hardware-implemented memristor convolutional neural network。忆阻器的精度很低,虽然外围的ADC是8bit,但忆阻器实际的精度有4bit就不错了。希望先用32bit浮点数训练网络,然后做量化,比较准确率的下降情况:
搭建网络
增加噪声
量化权重
量化数据流
测试的环境如下:
python 3.7.4, tensorflow 2.0.0
一、 搭建网络
1.数据集准备
import tensorflow as tf
import numpy as np
# 1.数据集准备
minst = tf.keras.datasets.mnist
img_rows,img_cols = 28,28
(x_train, y_train), (x_test, y_test) = minst.load_data()
# 卷积运算需要将原来的(6000,28,28)变成(6000,28,28,1) ,即增加通道的参数
x_train = x_train.reshape(x_train.shape[0],img_rows,img_cols,1)
x_test = x_test.reshape(x_test.shape[0],img_rows,img_cols,1)
# 需要将原来的0-255的整数转为32bit单精度浮点数,再归一化为[0,1]
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train = x_train / 255
x_test = x_test / 255
# 标签为独热码的形式,方便交叉熵运算
y_train_onehot = tf.keras.utils.to_categorical(y_train)
y_test_onehot = tf.keras.utils.to_categorical(y_test)
2. 模型搭建
keras搭建模型很方便:
# 2. 模型搭建
model = tf.keras.Sequential()
# 注意这里padding的类型“valid”,表示不填充外围,输出shape为(26,26,8)。并且没有设置bias,因为忆阻器硬件里不好添加
model.add(tf.keras.layers.Conv2D(8, kernel_size=(3, 3),padding="valid", activation='relu',use_bias=False,input_shape=(28, 28, 1)))
# 同样注意这里的padding类型“sample”,表示除不尽须填充而不是舍去,输出shape为(9,9,8)
model.add(tf.keras.layers.MaxPooling2D(pool_size=(3, 3),padding="same"))
# 同理,注意padding,输出shape=(7,7,12)
model.add(tf.keras.layers.Conv2D(12, kernel_size=(3, 3),padding="valid", activation='relu',use_bias=False,))
# 同理,注意padding,输出shape=(4,4,12)
model.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2),padding="same"))
model.add(tf.keras.layers.Flatten())
model.add(tf.keras.layers.Dense(10, use_bias=False,activation='softmax'))
model.summary()
三、开始训练
开始训练,数据集很小,cpu训练一两分钟左右就能达到98%准确率
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
from time import time
startTime = time()
history = model.fit(x_train, y_train_onehot, batch_size = 100, epochs = 10, verbose=2, validation_data = (x_test, y_test_onehot))
duration = time()-startTime
print("Train Finished! takes:","{:.2f}".format(duration))
score = model.evaluate(x_test, y_test_onehot, verbose=0)
print('Test accuracy:', score[1])
四、模型的保存和加载
如果还要后续操作,模型的保存和加载还是相当重要的。
# 1.保存框架,权重,优化器,损失函数
model.save('models/mnist_tf2_fw.h5')
# 2.保存框架,不含权重和配置
yaml_tring = model.to_yaml()
with open('./models/mnist_tf2_f.yaml','w') as model_file:
model_file.write(yaml_tring)
# 3.保存权重,不含框架和配置
model.save_weights('models/mnist_tf2_w.h5')
保存量化后的tflite格式,找了好久才搞定的!tflite格式主要是为了安卓端推理应用推出的:
#1 未量化-32bit
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()
open("models/tflite_model_32.tflite","wb").write(tflite_model)
# 2.float16量化
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_types = [tf.float16]
tflite_model = converter.convert()
open("models/tflite_model_16.tflite", "wb").write(tflite_model)
# 3.8bit量化
def representative_data_gen():
# *这里需要注意:函数需要获得x_train的shape信息
data = tf.data.Dataset.from_tensor_slices(x_train).batch(1).take(100)
for input_value in data:
yield [input_value]
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_data_gen
# Restricting supported target op specification to INT8
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
# Set the input and output tensors to uint8
converter.inference_input_type = tf.uint8
converter.inference_output_type = tf.uint8
# Convert and Save the model
tflite_model = converter.convert()
open("models/tflite_model_8.tflite", "wb").write(tflite_model)
# 4.动态量化
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()
open("models/tflite_model_dy.tflite", "wb").write(tflite_model)
五、小结
截止目前,我们已经做好了训练,分别保存了32bit、16bit、8bit的量化模型。接下来的工作是加载模型,查看增加噪声、量化后对精度的损失。
github 代码