pytorch标准化与模型训练推理以及中间层注意点-编程知识

1.图像归一化和通道转换操作

a = np.arange(3*3*3).reshape(3,3,3).astype(np.uint8)
print(a)
function = transforms.ToTensor()#注意只能转换3维度的ndarray或者PIL的Image类型
c = function(a)
print(c)'''
D:\anaconda3\python.exe E:\test\pythonProject\test.py 
[[[ 0  1  2][ 3  4  5][ 6  7  8]][[ 9 10 11][12 13 14][15 16 17]][[18 19 20][21 22 23][24 25 26]]]
tensor([[[0.0000, 0.0118, 0.0235],[0.0353, 0.0471, 0.0588],[0.0706, 0.0824, 0.0941]],[[0.0039, 0.0157, 0.0275],[0.0392, 0.0510, 0.0627],[0.0745, 0.0863, 0.0980]],[[0.0078, 0.0196, 0.0314],[0.0431, 0.0549, 0.0667],[0.0784, 0.0902, 0.1020]]])进程已结束，退出代码为 0
'''

注意： transforms.ToTensor()#注意只能转换3维度的ndarray或者PIL的Image类型的数据，源数据类型必须为uint8。

transforms.ToTensor()的作用是把RGB拆分为三通道R，G，B，然后再把每个数除以 255 归一化。

2.Normalize

a = np.arange(3*3*3).reshape(3,3,3).astype(np.float32)
b = torch.from_numpy(a)
trans1_5 = transforms.Normalize(mean=1,std=0.5)
trans3_3 = transforms.Normalize(mean=(1,2,3),std=(1,2,1))
print(a)
c = trans1_5(b)
d = trans3_3(b)
print(c)
print(d)''' 
D:\anaconda3\python.exe E:\test\pythonProject\test.py 
[[[ 0.  1.  2.][ 3.  4.  5.][ 6.  7.  8.]][[ 9. 10. 11.][12. 13. 14.][15. 16. 17.]][[18. 19. 20.][21. 22. 23.][24. 25. 26.]]]
tensor([[[-2.,  0.,  2.],[ 4.,  6.,  8.],[10., 12., 14.]],[[16., 18., 20.],[22., 24., 26.],[28., 30., 32.]],[[34., 36., 38.],[40., 42., 44.],[46., 48., 50.]]])
tensor([[[-1.0000,  0.0000,  1.0000],[ 2.0000,  3.0000,  4.0000],[ 5.0000,  6.0000,  7.0000]],[[ 3.5000,  4.0000,  4.5000],[ 5.0000,  5.5000,  6.0000],[ 6.5000,  7.0000,  7.5000]],[[15.0000, 16.0000, 17.0000],[18.0000, 19.0000, 20.0000],[21.0000, 22.0000, 23.0000]]])进程已结束，退出代码为 0'''

注意：transforms.Normalize() 转换的参数必须是float类型的tensor，当数据为3通道的时候输入的 MEAN和STD参数为列表或者三个数的元组时，是每个通道分别做上面公式的运算，从以上代码，以及打印数据可以看出来。

3.批标准化层

transforms.Normalize() transforms.Totensor()函数基本上都是在图像预处理阶段使用，他们都集成在 torchvision 这个库里面，而批标准化层一般在多层网络结构中都会使用它集成在 nn 模块里面，批标准化主要是为了解决梯度消失，加速收敛速度及稳定性的算法，经过批标准化，模型的形状是不变的，BatchNorm后是不改变输入的shape的；

nn.BatchNorm1d： N * d --> N * d

nn.BatchNorm2d: N * C * H * W -- > N * C * H * W

nn.BatchNorm3d: N * C * d * H * W --> N * C * d * H * W

我们常用的是 BatchNorm1d 和 BatchNorm2d，对于BatchNorm其主要参数为：

nn.BatchNorm1d(num_features, eps=1e-05, momentum=0.1, affine=True,track_running_stats=True, device=None, dtype=None)

主要参数介绍：

num_features: 输入维度，也就是数据的特征维度；

eps：是在分母上加的一个值，是为了防止分母为0的情况，让其能正常计算；

affine：是仿射变化，将分别初始化为1和0；

BatchNorm1d具体计算方式：

torch.var(）函数的参数 unbiased 为 True 则执行样本方差，unbiased 为 False 则执行母体方差(书本上教学的方差，正常理解的方差)。

（1）BatchNorm1d计算过程


t = torch.arange(6,dtype=torch.float32).view(2,3)
print("t",t)
print('----------------------------------')
me = t.mean(0)
print("t.mean",me)
print('----------------------------------')
print("t.var",t.var(0,False))#执行正常理解的方差
print('----------------------------------')
sq = torch.sqrt(t.var(0,False)+1e-5)
print("t.sqrt",sq)
print('----------------------------------')
x = (t-me)
print("t-me",x )
print('----------------------------------')
y = x/sq
print("x/sq",y )
print('----------------------------------')
bn1d = torch.nn.BatchNorm1d(3,1e-5,0.1,True,True,None,None)
print("weight:",bn1d.weight,"\r\n","bias:",bn1d.bias)
print('----------------------------------')
bnout = bn1d(t)
print("bnout:",bnout)
print('----------------------------------')'''
D:\anaconda3\python.exe E:\test\pythonProject\test.py 
t tensor([[0., 1., 2.],[3., 4., 5.]])
----------------------------------
t.mean tensor([1.5000, 2.5000, 3.5000])
----------------------------------
t.var tensor([2.2500, 2.2500, 2.2500])
----------------------------------
t.sqrt tensor([1.5000, 1.5000, 1.5000])
----------------------------------
t-me tensor([[-1.5000, -1.5000, -1.5000],[ 1.5000,  1.5000,  1.5000]])
----------------------------------
x/sq tensor([[-1.0000, -1.0000, -1.0000],[ 1.0000,  1.0000,  1.0000]])
----------------------------------
weight: Parameter containing:
tensor([1., 1., 1.], requires_grad=True) bias: Parameter containing:
tensor([0., 0., 0.], requires_grad=True)
----------------------------------
bnout: tensor([[-1.0000, -1.0000, -1.0000],[ 1.0000,  1.0000,  1.0000]], grad_fn=<NativeBatchNormBackward0>)
----------------------------------进程已结束，退出代码为 0
'''

注意： BatchNorm1d在模型训练模式的时候至少需要提供两组参数，在模型预测模式可以提供一组参数，在模型训练模式的时候至少需要提供两组参数组成2维的参数，因为训练的时候要根据两组参数来计算。BatchNorm1d平均值mean是按照列求的，目的是求这个批次的均值。

官方说明翻译：

将批量归一化应用于4D输入（具有额外通道维度的小批量2D输入），如论文《批量归一化：通过减少内部协变量偏移加速深度网络训练》中所述。
y = （x − E[x]）/（√（Var[x] + ϵ))*γ + β
平均值和标准偏差是在小批量的每个维度上计算的，γ和β是大小为C的可学习参数向量（其中C是输入大小）。默认情况下，γ的元素设置为1，而β的元素则设置为0。在前向通道的训练时间，通过有偏估计器计算标准偏差，等效于torc.var（输入，无偏=False）。然而，存储在标准偏差移动平均值中的值是通过无偏估计器计算的，相当于torc.var（输入，无偏=True）。
同样在默认情况下，在训练过程中，该层保持对其计算的平均值和方差的估计，然后在评估过程中用于归一化。运行估计值保持0.1的默认动量。
如果track_running_stats设置为False，则该层不保持运行估计，而是在评估期间使用批统计信息。
笔记
这个动量论点不同于优化器类中使用的动量论点和动量的传统概念。从数学上讲，这里运行统计数据的更新规则是新的 = 1. −  推进力 × x + 推进力 × xt，其中x是估计的统计量，xt是新的观测值。
由于批处理规范化是在C维度上完成的，计算（N，H，W）切片的统计信息，因此称之为“空间批处理规范”是一个常见的术语。

（1）BatchNorm2d计算过程

t = torch.arange(2*3*3*3,dtype=torch.float32).view(2,3,3,3)#生成tensor数据
print("t",t)
bn1d = torch.nn.BatchNorm2d(3,1e-5,0.1,True,True,None,None)
print("weight:",bn1d.weight,"\r\n","bias:",bn1d.bias)
print('----------------------------------')
bnout = bn1d(t)
print("bnout:",bnout)
print('----------------------------------')#取出来第二通道数据
x = [9., 10., 11.,12., 13., 14.,15., 16., 17.,36., 37., 38.,39., 40., 41.,42., 43., 44.]
x = np.array(x)
mean = x.mean()
print("mean",mean)
out = (x-mean)/np.sqrt(x.var()+1e-5)
print("out",out.reshape(2,3,3))
# x.var()   这个是求方差
# x.std()   这个是求标准差
# print(x.std(),x.var())''' 
D:\anaconda3\python.exe E:\test\pythonProject\test.py 
t tensor([[[[ 0.,  1.,  2.],[ 3.,  4.,  5.],[ 6.,  7.,  8.]],[[ 9., 10., 11.],[12., 13., 14.],[15., 16., 17.]],[[18., 19., 20.],[21., 22., 23.],[24., 25., 26.]]],[[[27., 28., 29.],[30., 31., 32.],[33., 34., 35.]],[[36., 37., 38.],[39., 40., 41.],[42., 43., 44.]],[[45., 46., 47.],[48., 49., 50.],[51., 52., 53.]]]])
weight: Parameter containing:
tensor([1., 1., 1.], requires_grad=True) bias: Parameter containing:
tensor([0., 0., 0.], requires_grad=True)
----------------------------------
bnout: tensor([[[[-1.2732, -1.2005, -1.1277],[-1.0550, -0.9822, -0.9094],[-0.8367, -0.7639, -0.6912]],[[-1.2732, -1.2005, -1.1277],[-1.0550, -0.9822, -0.9094],[-0.8367, -0.7639, -0.6912]],[[-1.2732, -1.2005, -1.1277],[-1.0550, -0.9822, -0.9094],[-0.8367, -0.7639, -0.6912]]],[[[ 0.6912,  0.7639,  0.8367],[ 0.9094,  0.9822,  1.0550],[ 1.1277,  1.2005,  1.2732]],[[ 0.6912,  0.7639,  0.8367],[ 0.9094,  0.9822,  1.0550],[ 1.1277,  1.2005,  1.2732]],[[ 0.6912,  0.7639,  0.8367],[ 0.9094,  0.9822,  1.0550],[ 1.1277,  1.2005,  1.2732]]]], grad_fn=<NativeBatchNormBackward0>)
----------------------------------
mean 26.5
out [[[-1.27321838 -1.20046305 -1.12770771][-1.05495237 -0.98219704 -0.9094417 ][-0.83668637 -0.76393103 -0.69117569]][[ 0.69117569  0.76393103  0.83668637][ 0.9094417   0.98219704  1.05495237][ 1.12770771  1.20046305  1.27321838]]]进程已结束，退出代码为 0
'''

以上代码的通道2，bn计算后的值和np按照公式计算出来的值一样。

注意：BatchNorm2d的均值是按照通道内所有数据求和除以个数得来的，比如（b，c，w，h），求通道一均值，把 b 批次内所有通道1数据全部加起来除以个数求mean均值，其他通道类似，每个通道互不干扰。

4.Dropout

当一个复杂的前馈神经网络被训练在小的数据集时，容易造成过拟合。为了防止过拟合，可以通过阻止特征检测器的共同作用来提高神经网络的性能。Dropout会随机选取一些张量置为0，阻止梯度向后传播，是为了减少张量之间的依赖关系，让模型学到更多特征。

t = torch.arange(6,dtype=torch.float32).view(1,-1,3)
print(t)
dp = torch.nn.Dropout1d(0.5)
dpt = dp(t)
print(dpt)'''
D:\anaconda3\python.exe E:\test\pythonProject\test.py 
tensor([[[0., 1., 2.],[3., 4., 5.]]])
tensor([[[0., 2., 4.],[0., 0., 0.]]])进程已结束，退出代码为 0
'''

Dropout1d支持2维和3维输入，随机置0输入，不置0的输入变为，输入/Dropout1d概率，置0输入可以让梯度不往后面再进行传输。

t = torch.arange(27,dtype=torch.float32).view(1,3,3,3)
print(t)
dp = torch.nn.Dropout2d(0.5)
dpt = dp(t)
print(dpt)'''
D:\anaconda3\python.exe E:\test\pythonProject\test.py 
tensor([[[[ 0.,  1.,  2.],[ 3.,  4.,  5.],[ 6.,  7.,  8.]],[[ 9., 10., 11.],[12., 13., 14.],[15., 16., 17.]],[[18., 19., 20.],[21., 22., 23.],[24., 25., 26.]]]])
tensor([[[[ 0.,  2.,  4.],[ 6.,  8., 10.],[12., 14., 16.]],[[ 0.,  0.,  0.],[ 0.,  0.,  0.],[ 0.,  0.,  0.]],[[36., 38., 40.],[42., 44., 46.],[48., 50., 52.]]]])进程已结束，退出代码为 0
'''

Dropout2d支持4维的输入（bach,c,w,h）,随机置 0 某个通道，不置0的输入变为，输入/Dropout1d概率，置0输入可以让梯度不往后面再进行传输。

注意： Dropout 是在模型训练的时候才起作用，在模型预测的时候不起作用，BatchNorm在训练的时候会优化自己的参数，在预测模式时候保持参数不变，也不会改变输出数值，所以在不同使用场景要设置模型为不同的模式。

模型训练模式和预测模式调用以下函数改变状态：

model.train()#模型处于训练模式
model.eval()#模型处于预测模式