Alex提出的alexnet网络结构模型，在imagenet2012图像分类challenge上赢得了冠军。作者训练alexnet网络时大致将120万张图像的训练集循环了90次，在两个NVIDIA GTX 580 3GB GPU上花了五到六天。
来源论文：Krizhevsky, Alex, Ilya Sutskever, and Geoffrey E. Hinton. “Imagenet classification with deep convolutional neural networks.” Advances in neural information processing systems. 2012.”
一 AlexNet创新点：
1 使用Relu替换之前的sigmoid的作为激活函数
2 使用了数据增强策略（Data Augmentation），抑制过拟合
3 使用了重叠的最大池化（Max Pooling）。此前的CNN通常使用平均池化，而AlexNet全部使用最大池化，成功避免了平均池化带来的模糊化效果
4 提出LRN（局部响应归一化）
5 成功使用Dropout机制，抑制过拟合
6 多GPU训练
详细介绍如下：
1 ReLu作为激活函数
在最初的感知机模型中，输入和输出的关系如下：
只是单纯的线性关系，这样的网络结构有很大的局限性：即使用很多这样结构的网络层叠加，其输出和输入仍然是线性关系，无法处理有非线性关系的输入输出。因此，对每个神经元的输出做个非线性的转换也就是，将上面就加权求和的结果输入到一个非线性函数，也就是激活函数中。 这样，由于激活函数的引入，多个网络层的叠加就不再是单纯的线性变换，而是具有更强的表现能力。在最初，sigmoid和tanh函数最常用的激活函数。
**sigmoid：**在网络层数较少时，sigmoid函数的特性能够很好的满足激活函数的作用。它把一个实数压缩至0到1之间，当输入的数字非常大的时候，结果会接近1；当输入非常大的负数时，则会得到接近0的结果。这种特性，能够很好的模拟神经元在受刺激后，是否被激活向后传递信息（输出为0，几乎不被激活；输出为1，完全被激活）。
sigmoid一个很大的问题就是梯度饱和。 观察sigmoid函数的曲线，当输入的数字较大（或较小）时，其函数值趋于不变，其导数变的非常的小。这样，在层数很多的的网络结构中，进行反向传播时，由于很多个很小的sigmoid导数累成，导致其结果趋于0，权值更新较慢。
**ReLu：**针对sigmoid梯度饱和导致训练收敛慢的问题，在AlexNet中引入了ReLU。ReLU是一个分段线性函数，小于等于0则输出为0；大于0的则恒等输出。相比于sigmoid，ReLU有以下特点：
（1）计算开销小。sigmoid的正向传播有指数运算，倒数运算，而ReLu是线性输出；反向传播中，sigmoid有指数运算，而ReLU有输出的部分，导数始终为1。
（2）梯度饱和问题
（3）稀疏性。Relu会使一部分神经元的输出为0，这样就造成了网络的稀疏性，并且减少了参数的相互依存关系，缓解了过拟合问题的发生。
这里有个问题，前面提到，激活函数要用非线性的，是为了使网络结构有更强的表达的能力。那这里使用ReLU本质上却是个线性的分段函数，是怎么进行非线性变换的。
这里把神经网络看着一个巨大的变换矩阵M，其输入为所有训练样本组成的矩阵A，输出为矩阵B。这里的M是一个线性变换的话，则所有的训练样本A进行了线性变换输出为B。
那么对于ReLU来说，由于其是分段的，0的部分可以看做神经元没有激活，不同的神经元激活或者不激活，其神经元组成的变换矩阵是不一样的。
设有两个训练样本 a1,a2，其训练时神经网络组成的变换矩阵为M1,M2。 由于M1变换对应的神经网络中激活神经元和M2是不一样的，这样M1,M2实际上是两个不同的线性变换。也就是说，每个训练样本使用的线性变换矩阵Mi是不一样的，在整个训练样本空间来说，其经历的是非线性变换。
简单来说，不同训练样本中的同样的特征，在经过神经网络学习时，流经的神经元是不一样的（激活函数值为0的神经元不会被激活）。这样，最终的输出实际上是输入样本的非线性变换。单个训练样本是线性变换，但是每个训练样本的线性变换是不一样的，这样整个训练样本集来说，就是非线性的变换。
传统神经网络激活函数通常为反正切或是sigmoid，AlexNet使用RELU作为激活函数，相比于反正切，该方法训练速度大约有6倍提升。RELU激活函数简单到难以置信。
2 数据增强
神经网络由于训练的参数多，需要比较多的数据量，不然很容易过拟合。当训练数据有限时，可以通过一些变换从已有的训练数据集中生成一些新的数据，以快速地扩充训练数据。对于图像数据集来说，可以对图像进行一些形变操作：
（1）翻转
（2）随机裁剪
（3）平移，颜色光照的变换
AlexNet中对数据做了以下操作：
（1）随机裁剪，对256×256的图片进行随机裁剪到227×227，然后进行水平翻转。
（2）测试的时候，对左上、右上、左下、右下、中间分别做了5次裁剪，然后翻转，共10个裁剪，之后对结果求平均。
（3）对RGB通道使用了PCA（主成分分析），对每个训练图片的每个像素，提取出RGB三个通道的特征向量与特征值，对每个特征值乘以一个α，α是一个均值0.1方差服从高斯分布的随机变量。也就是对颜色、光照作变换，结果使错误率又下降了1%。
3 层叠池化
在LeNet中池化是不重叠的，即池化的窗口的大小和步长是相等的，如下：
在AlexNet中使用的池化（Pooling）却是可重叠的，也就是说，在池化的时候，每次移动的步长小于池化的窗口长度。AlexNet池化的大小为3×3的正方形，每次池化移动步长为2，这样就会出现重叠。重叠池化可以避免过拟合，这个策略贡献了0.3%的Top-5错误率。与非重叠方案s=2，z=2s=2，z=2相比，输出的维度是相等的，并且能在一定程度上抑制过拟合。
4 局部响应归一化
ReLU具有让人满意的特性，它不需要通过输入归一化来防止饱和。如果至少一些训练样本对ReLU产生了正输入，那么那个神经元上将发生学习。然而，我们仍然发现接下来的局部响应归一化有助于泛化。a(x,y)(i)表示神经元激活，通过在(x,y)位置应用核i，然后应用ReLU非线性来计算，响应归一化激活b(x,y)(i)通过下式给定：
其中，N是卷积核的个数，也就是生成的FeatureMap的个数；k,α,β,n是超参数，论文中使用的值是k=2,n=5,α=10(-4),β=0.75。
输出b(x,y)(i)和输入a(x,y)(j)的上标表示的是当前值所在的通道，也即是叠加的方向是沿着通道进行。将要归一化的值a(x,y)(i)所在附近通道相同位置的值的平方累加起来
Hinton等人认为LRN层模仿生物神经系统的侧抑制机制，对局部神经元的活动创建竞争机制，使得响应比较大的值相对更大，提高模型泛化能力。但是，后来的论文比如Very Deep Convolution Networks for Large-Scale Image Recognition（也就是提出VGG网络的文章）中证明，LRN对CNN并没有什么作用，反而增加了计算复杂度，因此，这一技术也不再使用了。
5 Dropout
这个是比较常用的抑制过拟合的方法了。
引入Dropout主要是为了防止过拟合。在神经网络中Dropout通过修改神经网络本身结构来实现，对于某一层的神经元，通过定义的概率将神经元置为0，这个神经元就不参与前向和后向传播，就如同在网络中被删除了一样，同时保持输入层与输出层神经元的个数不变，然后按照神经网络的学习方法进行参数更新。在下一次迭代中，又重新随机删除一些神经元（置为0），直至训练结束。
Dropout应该算是AlexNet中一个很大的创新，现在神经网络中的必备结构之一。Dropout也可以看成是一种模型组合，每次生成的网络结构都不一样，通过组合多个模型的方式能够有效地减少过拟合，Dropout只需要两倍的训练时间即可实现模型组合（类似取平均）的效果，非常高效。
如下图：
在AlexNet中，在训练时，每层的keep_prob被设置为0.5，而在测试时，所有的keep_prob都为1.0，也即关闭dropout，并把所有神经元的输出均乘以0.5，保证训练时和测试时输出的均值接近。当然，dropout只用于全连接层。没有dropout，AlexNet网络将会遭遇严重的过拟合，加入dropout后，网络的收敛速度慢了接近一倍。
二 AlexNet网络结构
AlexNet和LeNet -5-网络有些许不同，在LeNet-5网络里，卷积层和池化层是分开的，即一层卷积层一层池化这样分布的，但是AlexNet网络卷积和池化层合为一体了，而且还是分两路设计网络。
（一）总体概述下：
（1）AlexNet为8层结构，其中前5层为卷积层，后面3层为全连接层；学习参数有6千万个，神经元有650,000个。
（2）AlexNet在两个GPU上运行。
（3）AlexNet在第2,4,5层均是前一层自己GPU内连接，第3层是与前面两层全连接，全连接是2个GPU全连接。
（4）LRN层第1,2个卷积层后。
（5）Max pooling层在LRN层以及第5个卷积层后。
（6）ReLU在每个卷积层以及全连接层后。
（7）Dropout层减少过度拟合，应用在前两个全连接层。
（二）详解各层训练参数的计算：
前五层：卷积层
后三层：全连接层
整体计算图：
（三）详解AlexNet网络的各层：
卷积层C1
该层的处理流程是： 卷积–>ReLU–>池化–>归一化。
（1）卷积，输入是227×227*3，使用96个11×11×3（卷积核最后一个的维数一定与输入最后一个的维数相同）的卷积核，得到的FeatureMap为55×55×96。
（2）ReLU，将卷积层输出的FeatureMap输入到ReLU函数中。
（3）池化，使用3×3步长为2的池化单元（重叠池化，步长小于池化单元的宽度），输出为27×27×96（(55−3)/2+1=27。
（4）局部响应归一化，使用k=2,n=5,α=10(−4),β=0.75进行局部归一化，输出的仍然为27×27×96，输出分为两组，每组的大小为27×27×48。
卷积层C2
该层的处理流程是：卷积–>ReLU–>池化–>归一化
（1）卷积，输入是2组27×27×48。使用2组，每组128个尺寸为5×5×48的卷积核，并作了边缘填充padding=2，卷积的步长为1. 则输出的FeatureMap为2组，每组的大小为27×27 times128。（(27+2∗2−5)/1+1=27
（2）ReLU，将卷积层输出的FeatureMap输入到ReLU函数中。
（3）池化运算的尺寸为3×3，步长为2，池化后图像的尺寸为(27−3)/2+1=13，输出为13×13×256。
（4）局部响应归一化，使用k=2,n=5,α=10(−4),β=0.75进行局部归一化，输出的仍然为13×13×256，输出分为2组，每组的大小为13×13×128。
卷积层C3
该层的处理流程是： 卷积–>ReLU
（1）卷积，输入是13×13×256，使用2组共384尺寸为3×3×256的卷积核，做了边缘填充padding=1，卷积的步长为1。则输出的FeatureMap为13×13×384。
（2）ReLU，将卷积层输出的FeatureMap输入到ReLU函数中。
卷积层C4
该层的处理流程是： 卷积–>ReLU
该层和C3类似。
（1）卷积，输入是13×13×384，分为两组，每组为13×13×192。使用2组，每组192个尺寸为3×3×192的卷积核，做了边缘填充padding=1，卷积的步长为1。则输出的FeatureMap为13×13 times384，分为两组，每组为13×13×192。
（2）ReLU，将卷积层输出的FeatureMap输入到ReLU函数中。
卷积层C5
该层处理流程为：卷积–>ReLU–>池化
（1）卷积，输入为13×13×384，分为两组，每组为13×13×192。使用2组，每组为128尺寸为3×3×192的卷积核，做了边缘填充padding=1，卷积的步长为1。则输出的FeatureMap为13×13×256。
（2）ReLU，将卷积层输出的FeatureMap输入到ReLU函数中。
（3）池化，池化运算的尺寸为3×3，步长为2，池化后图像的尺寸为 (13−3)/2+1=6,即池化后的输出为6×6×256。
全连接层FC6
该层的流程为：（卷积）全连接 -->ReLU -->Dropout
（1）卷积->全连接： 输入为6×6×256,该层有4096个卷积核，每个卷积核的大小为6×6×256。由于卷积核的尺寸刚好与待处理特征图（输入）的尺寸相同，即卷积核中的每个系数只与特征图（输入）尺寸的一个像素值相乘，一一对应，因此，该层被称为全连接层。由于卷积核与特征图的尺寸相同，卷积运算后只有一个值，因此，卷积后的像素层尺寸为4096×1×1，即有4096个神经元。
（2）ReLU,这4096个运算结果通过ReLU激活函数生成4096个值。
（3）Dropout,抑制过拟合，随机的断开某些神经元的连接或者是不激活某些神经元。
全连接层FC7
流程为：全连接–>ReLU–>Dropout
（1）全连接，输入为4096的向量。
（2）ReLU,这4096个运算结果通过ReLU激活函数生成4096个值。
（3）Dropout,抑制过拟合，随机的断开某些神经元的连接或者是不激活某些神经元。
输出层
第七层输出的4096个数据与第八层的1000个神经元进行全连接，经过训练后输出1000个float型的值，这就是预测结果。
AlexNet参数数量
卷积层的参数 = 卷积核的数量 * 卷积核 + 偏置
C1: 96个11×11×3的卷积核，96×11×11×3+96=34848
C2: 2组，每组128个5×5×48的卷积核，(128×5×5×48+128)×2=307456
C3: 384个3×3×256的卷积核，3×3×256×384+384=885120
C4: 2组，每组192个3×3×192的卷积核，(3×3×192×192+192)×2=663936
C5: 2组，每组128个3×3×192的卷积核，(3×3×192×128+128)×2=442624
FC6: 4096个6×6×256的卷积核，6×6×256×4096+4096=37752832
FC7: 4096∗4096+4096=16781312
output: 4096∗1000=4096000
卷积层 C2,C4,C5中的卷积核只和位于同一GPU的上一层的FeatureMap相连。从上面可以看出，参数大多数集中在全连接层，在卷积层由于权值共享，权值参数较少。
（四）Details of Learning 学习中的细节
（1）输入是224×224224×224，不过经过计算(224−11)/4=54.75并不是论文中的55×55，而使用227×227作为输入，则(227−11)/4=55。
（2）输入的图片的像素是224x224的且有三层，这三层代表三原色RGB（我们知道所谓的彩色其实就是三原色组合而成的，因此彩色图片也是这样），我们可以简单的看做有三张图片堆叠而成的彩色图片，这三张图片分别对应红色，绿色，蓝色，在LeNet -5-网络只有一层，因为颜色是灰度的。输入层的采样窗口为11×11且也有三层对应图片的三层，那么每采样一次有多少个连接呢？有11x11x3 = 363个，采样窗口的平移步长是4，（在LeNet -5-网络移动步长是1，这里是4，应该很容易理解）为什么步长是4而不是1呢？因为考虑到计算量的问题，如果是1步计算量太大。那么这样的采样窗口在图像上采样后的维度是多少呢？
（3）AlexNet使用了mini-batch SGD，batch的大小为128，梯度下降的算法选择了momentum，参数为0.9，加入了L2正则化，或者说权重衰减，参数为0.0005。论文中提到，这么小的权重衰减参数几乎可以说没有正则化效果，但对模型的学习非常重要。
（4）每一层权重均初始化为0均值0.01标准差的高斯分布，在第二层、第四层和第五层卷积的偏置被设置为1.0，而其他层的则为0，目的是为了加速早期学习的速率（因为激活函数是ReLU，1.0的偏置可以让大部分输出为正）。
（5）对于所有层都使用了相等的学习率，这是在整个训练过程中手动调整的。学习速率初始值为0.01，在训练结束前共减小3次，每次减小都出现在错误率停止减少的时候，每次减小都是把学习速率除以10 。
（6）深度很重要，去掉任一层，性能都会降低。
（7）为了简化实验，没有使用非监督预训练。但是当有足够计算能力扩大网络结构，而没增加相应数据时，非监督预训练可能会有所帮助。
三 代码实现（Pytorch）
主要参考 https://www.bilibili.com/video/BV1W7411T7qc
这部分搭建AlexNet网络并训练花分类数据集。
1 数据集下载。
http://download.tensorflow.org/example_images/flower_photos.tgz
包含 5 中类型的花，每种类型有600~900张图像不等。将flower_photos拷贝到flower_data文件夹下，并解压缩。
2 对数据集进行划分，划分为训练集与验证集。
由于此数据集不像 CIFAR10 那样下载时就划分好了训练集和测试集，因此需要自己划分。split_data.py会按照9:1的比例将数据集分为训练集和验证集。
在split_data.py的当前页面，shift + 右键 打开 PowerShell 窗口，输入 python split_data.py，就会自动进行转换了。
划分以后的数据集目录如下：
|-- flower_data
|-- flower_photos
|-- daisy
|-- dandelion
|-- roses
|-- sunflowers
|-- tulips
|-- LICENSE.txt
|-- train
|-- daisy
|-- dandelion
|-- roses
|-- sunflowers
|-- tulips
|-- val
|-- daisy
|-- dandelion
|-- roses
|-- sunflowers
|-- tulips
|-- flower_photos.tgz
|-- flower_link.txt
|-- README.md
|-- split_data.py
3 注释model.py。
import torch.nn as nn
import torch
class AlexNet(nn.Module):
def __init__(self, num_classes=1000, init_weights=False):
super(AlexNet, self).__init__()
#与LeNet不一样的地方
#用nn.Sequential模块，可以将一系列的层结构进行打包，组合成一个新的结构，在这里取名叫features
self.features = nn.Sequential(
#padding可以传入整形或者tuple(1,2)。如果传入整形1，那就会在特征矩阵的上下各补一行零，左右两侧各补一列零。
# tuple(1,2)表示上下各补一行零，左右两侧各补两列零
#如果想更精确，就要用官网的nn.ZeroPad2d（（1,2,1,2）），左侧补一列，右侧补两列，上方补一行，下方补两行
nn.Conv2d(3, 48, kernel_size=11, stride=4, padding=2), # input[3, 224, 224] output[48, 55, 55]
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2), # output[48, 27, 27]
nn.Conv2d(48, 128, kernel_size=5, padding=2), # output[128, 27, 27]
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2), # output[128, 13, 13]
nn.Conv2d(128, 192, kernel_size=3, padding=1), # output[192, 13, 13]
nn.ReLU(inplace=True),
nn.Conv2d(192, 192, kernel_size=3, padding=1), # output[192, 13, 13]
nn.ReLU(inplace=True),
nn.Conv2d(192, 128, kernel_size=3, padding=1), # output[128, 13, 13]
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2), # output[128, 6, 6]
)
#包含了三层全连接层
self.classifier = nn.Sequential(
#dropout方法可以让全连接层的神经元按照一定比例失活，预防过拟合
nn.Dropout(p=0.5),
nn.Linear(128 * 6 * 6, 2048),
nn.ReLU(inplace=True),
nn.Dropout(p=0.5),
nn.Linear(2048, 2048),
nn.ReLU(inplace=True),
#输入是上一层的输出，输出是数据集类别的个数，这里花的种类是5种
#num_classes 是在初始化类的时候传进来的，def __init__(self, num_classes=1000, init_weights=False)
#默认num_classes=1000，这里是5个类别，初始化的时候传入5就可以了
nn.Linear(2048, num_classes),
)
#初始化权重
#搭建网络过程中，初始化类的时候，def __init__(self, num_classes=1000, init_weights=False):
#如果传入的参数init_weights=True，就会初始化权重
#这里讲了一个初始化权重的方法，但其实不需要。Pytorch会自动对卷基层和全连接层进行权重的初始化
if init_weights:
self._initialize_weights()
def forward(self, x):
x = self.features(x)
#展平处理，展平的维度从第1维开始，第0维batch不动
#从从第1维开始，C*H*W 展成一个一维向量
x = torch.flatten(x, start_dim=1)
x = self.classifier(x)
return x
def _initialize_weights(self):
#遍历网络中所有的模块，也就是会迭代定义的每一个层结构
for m in self.modules():
#判断得到的层结构的类型，如果是nn.Conv2d类型
if isinstance(m, nn.Conv2d):
#用这个方法kaiming_normal_，对权重进行初始化
nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
if m.bias is not None:
nn.init.constant_(m.bias, 0)
#如果传进来的实例是全连接层，通过正态分布normal_，给权重赋值。正态分布的均值是0，方差是0.01
elif isinstance(m, nn.Linear):
nn.init.normal_(m.weight, 0, 0.01)
nn.init.constant_(m.bias, 0)
4 注释train.py。
import os
import sys
import json
import torch
import torch.nn as nn
from torchvision import transforms, datasets, utils
import matplotlib.pyplot as plt
import numpy as np
import torch.optim as optim
from tqdm import tqdm
from model import AlexNet
import time
def main():
#指定训练中使用的设备
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print("using {} device.".format(device))
#数据预处理，transforms.RandomResizedCrop(224)随机裁剪，裁剪到224*224的大小
#transforms.RandomHorizontalFlip()水平方向随机翻转
#ToTensor()转化为Tensor
#Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))进行标准化处理
data_transform = {
"train": transforms.Compose([transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),
"val": transforms.Compose([transforms.Resize((224, 224)), # cannot 224, must (224, 224)
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])}
#获取数据集所在的根目录
#os.getcwd()获取当前文件所在的目录
#os.path.join(os.getcwd(), "../..")将os.getcwd()和"../.."两个路径连在一起，“..”表示返回上一层目录
#"../.."表示返回上上层目录
data_root = os.path.abspath(os.path.join(os.getcwd(), "../..")) # get data root path
image_path = os.path.join(data_root, "data_set", "flower_data") # flower data set path
assert os.path.exists(image_path), "{} path does not exist.".format(image_path)
#加载训练集数据集，root=os.path.join(image_path, "train")是加载训练集数据集的路径
train_dataset = datasets.ImageFolder(root=os.path.join(image_path, "train"),
transform=data_transform["train"])
#统计训练集有多少张图片
train_num = len(train_dataset)
# {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
#获取分类的名称所对应的索引
#class_to_idx是个字典，包含每一种类别所对应的索引值，可以设个断点看一下
flower_list = train_dataset.class_to_idx
#遍历字典，将字典的key和value反过来
cla_dict = dict((val, key) for key, val in flower_list.items())
# write dict into json file
#对cla_dict这个字典进行编码，编码成json的格式
json_str = json.dumps(cla_dict, indent=4)
#打开class_indices.json文件，保存信息
with open('class_indices.json', 'w') as json_file:
json_file.write(json_str)
batch_size = 32
nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8]) # number of workers
print('Using {} dataloader workers every process'.format(nw))
#通过DataLoader把训练集train_dataset加载进来，根据batch_size和随机参数，从样本中随机的获取一批批的数据
#num_workers表示加载数据所使用的的线程个数，在windows系统下，是不能设置为非0值得
#num_workers=0表示，使用一个主线程加载数据
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=batch_size, shuffle=True,
num_workers=nw)
validate_dataset = datasets.ImageFolder(root=os.path.join(image_path, "val"),
transform=data_transform["val"])
val_num = len(validate_dataset)
validate_loader = torch.utils.data.DataLoader(validate_dataset,
batch_size=batch_size, shuffle=False,
num_workers=nw)
print("using {} images for training, {} images for validation.".format(train_num,
val_num))
#注释掉的部分是如何查看数据集的代码
#可以先把validate_loader里的batch_size改为4 # #val_num))
#shuffle=False表示随机打乱，改为 shuffle=True，否则按顺序读取的话会是同一个文件夹，同一个种类
# test_data_iter = iter(validate_loader)
# test_image, test_label = test_data_iter.next()
#
# def imshow(img):
# img = img / 2 + 0.5 # unnormalize
# npimg = img.numpy()
# plt.imshow(np.transpose(npimg, (1, 2, 0)))
# plt.show()
#
# print(' '.join('%5s' % cla_dict[test_label[j].item()] for j in range(4)))
# imshow(utils.make_grid(test_image))
net = AlexNet(num_classes=5, init_weights=True)
net.to(device)
#损失函数，多类别的损失交叉熵函数
loss_function = nn.CrossEntropyLoss()
# pata = list(net.parameters())
#采用Adam优化器，优化对象是网络中所有可训练的参数net.parameters()
#lr=0.0002学习率实验中获得，调大调小对准确率的影响可以看一下
optimizer = optim.Adam(net.parameters(), lr=0.0002)
epochs = 10
#保存权重的路径
save_path = './AlexNet.pth'
#定义最佳准确率。为了在训练网络过程中，保存准确率最高的那次训练的模型
best_acc = 0.0
train_steps = len(train_loader)
#下面开始训练
for epoch in range(epochs):
# train
net.train()#启用dropout方法
running_loss = 0.0#统计训练过程中的平均损失
#统计训练一个epoch所需要的时间
t1=time.perf_counter()
train_bar = tqdm(train_loader, file=sys.stdout)
#遍历数据集
for step, data in enumerate(train_bar):
#将数据分为对应的图像和标签
images, labels = data
#清空之前的梯度信息
optimizer.zero_grad()
outputs = net(images.to(device))
#计算预测值与真实值的损失
loss = loss_function(outputs, labels.to(device))
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1,
epochs,
loss)
#用*和.打印训练进度，rate是训练进度
print()
print(time.perf_counter()-t1)
# validate
net.eval()#关闭dropout方法
acc = 0.0 # accumulate accurate number / epoch
with torch.no_grad():#验证过程中不计算损失梯度
val_bar = tqdm(validate_loader, file=sys.stdout)
#遍历验证集
for val_data in val_bar:
#将数据划分为对应的图片和标签
val_images, val_labels = val_data
outputs = net(val_images.to(device))
#通过torch.max求得输出中最有可能的那个类别
predict_y = torch.max(outputs, dim=1)[1]
#将预测值和真实标签进行对比orch.eq(predict_y, val_labels.to(device))
#acc累积验证集预测正确的样本个数
acc += torch.eq(predict_y, val_labels.to(device)).sum().item()
#验证集的准确率
val_accurate = acc / val_num
print('[epoch %d] train_loss: %.3f val_accuracy: %.3f' %
(epoch + 1, running_loss / train_steps, val_accurate))
if val_accurate > best_acc:
best_acc = val_accurate
#保存当前的权重
torch.save(net.state_dict(), save_path)
print('Finished Training')
if __name__ == '__main__':
main()
class_indices.json文件：
5 注释predict.py。
import os
import json
import torch
from PIL import Image
from torchvision import transforms
import matplotlib.pyplot as plt
from model import AlexNet
def main():
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
data_transform = transforms.Compose(
[transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
# load image
img_path = "../tulip.jpg"
assert os.path.exists(img_path), "file: '{}' dose not exist.".format(img_path)
img = Image.open(img_path)
plt.imshow(img)
# [N, C, H, W]
img = data_transform(img)
# expand batch dimension
#扩充一个维度，因为读入的图片只有高度，宽度和深度三个维度
img = torch.unsqueeze(img, dim=0)
# read class_indict
json_path = './class_indices.json'
assert os.path.exists(json_path), "file: '{}' dose not exist.".format(json_path)
json_file = open(json_path, "r")
# 读取索引对应的类别名称，并解码，解成需要使用的字典
class_indict = json.load(json_file)
# create model
model = AlexNet(num_classes=5).to(device)#初始化网络
# load model weights
weights_path = "./AlexNet.pth"
assert os.path.exists(weights_path), "file: '{}' dose not exist.".format(weights_path)
#载入网络模型
model.load_state_dict(torch.load(weights_path))
model.eval()#关闭dropout模式
with torch.no_grad():#pytorch不去跟踪变量的损失梯度
# predict class
#数据经过正向传播得到输出，然后将输出进行压缩，将batch维度压缩掉
output = torch.squeeze(model(img.to(device))).cpu()
#经softmax处理后变成一个概率分布
predict = torch.softmax(output, dim=0)
#通过torch.argmax方法，获取概率最大处所对应的索引值
predict_cla = torch.argmax(predict).numpy()
#但因类别名称，以及他所对应的类别概率
print_res = "class: {} prob: {:.3}".format(class_indict[str(predict_cla)],
predict[predict_cla].numpy())
plt.title(print_res)
for i in range(len(predict)):
print("class: {:10} prob: {:.3}".format(class_indict[str(i)],
predict[i].numpy()))
plt.show()
if __name__ == '__main__':
main()
6 程序运行过程中各种问题。
（1）python包tqdm（进度条）安装
conda install -c conda-forge tqdm
（2）深度学习训练过程中loss变化情况
以下内容参考https://blog.csdn.net/qq_42363032/article/details/122489704
**数据集说明**
**训练集**是用于模型的训练的样本集合，确定模型的权重参数。
训练集的数量随着模型的复杂度要增多。
反向传播确定最优参数。
**验证集**用于验证模型的评估、模型的选择、参数的调整。
选择模型、调整超参、初步评估模型。
**测试集**是用于模型的无偏估计。
再找个集合评估模型看看是否是偶然稳定，即验证无偏性。
保证同分布，最好保证测试集的正负比和实际环境的一致。
如果模型在训练集、验证集、测试集的表现都很好，但是在实际用的新数据表现很差，可能的问题：
分布不一致，新数据与原数据的特征之间存在差异，网络对新数据特征的提取能力不足。
**loss说明**
train loss 下降↓，val loss 下降 ↓：训练正常，网络仍在学习，最好的情况。
train loss 下降 ↓，val loss：上升/不变：有点过拟合overfitting，可以停掉训练，用过拟合方法如数据增强、正则、dropout、max pooling等。
train loss 稳定，val loss 下降：数据有问题，检查数据标注有没有错，分布是否一直，是否shuffle。
train loss 稳定，val loss 稳定：学习过程遇到瓶颈，可以尝试调小学习率或batch数量
train loss 上升 ↑，val loss 上升 ↑：网络结构设计不当，参数不合理，数据集需清洗等，最差情况。
**loss震荡**
轻微震荡是正常的，在一定范围内，一般来说batch size越大，其确定的下降方向越准，引起训练震荡越小。如果震荡十分剧烈，估计是batch size设置太小了。
**train loss下降，val loss上升
网络过拟合的解决**
学习率衰减
dropout
减少层数、神经元个数
加BN
Early Stopping，可以让val loss有上升趋势的时候早停掉
**loss上升，acc也上升**
如果val loss平稳，可以接着训。
如果val loss轻微震荡，也可以接受。以对数损失为例，假如正类预测概率为0.51，但是＞0.5的。此时的loss很大，但acc是增加的。
如果val loss一直在上升，就要考虑过拟合的问题。因为，既然val的acc在上升，那多半train的损失还在降或者收敛了，而val的损失不断上升，一直下去就变成train loss远小于val loss了，就意味着过拟合。如果准确率达到要求，可以早停掉。或尝试过拟合方法。
**train loss不下降**
a 模型结构问题。当模型结构不好、规模小时，模型对数据的拟合能力不足。
训练时间问题。不同的模型有不同的计算量，当需要的计算量很大时，耗时也会很大
b 权重初始化问题。常用的初始化方案有全零初始化、正态分布初始化和均匀分布初始化等，合适的初始化方案很重要，神经网络初始化为0可能会带来影响
c 正则化问题。L1、L2以及Dropout是为了防止过拟合的，当训练集loss下不来时，就要考虑一下是不是正则化过度，导致模型欠拟合了。
d 激活函数问题。全连接层多用ReLu，神经网络的输出层会使用sigmoid 或者 softmax。在使用Relu激活函数时，当每一个神经元的输入为负时，会使得该神经元输出恒为0，导致失活，由于此时梯度为0，无法恢复。
e 优化器问题。优化器一般选取Adam，但是当Adam难以训练时，需要使用如SGD之类的其他优化器。
f 学习率问题。学习率决定了网络的训练速度，但学习率不是越大越好，当网络趋近于收敛时应该选择较小的学习率来保证找到更好的最优点。所以，我们需要手动调整学习率，首先选择一个合适的初始学习率，当训练不动之后，稍微降低学习率。
g 梯度消失和爆炸。这时需要考虑激活函数是否合理，网络深度是否合理，可以通过调节sigmoid -> relu，假如残差网络等。
h batch size问题。过小，会导致模型损失波动大，难以收敛，过大时，模型前期由于梯度的平均，导致收敛速度过慢。
i 数据集问题。（1）数据集未打乱，可能会导致网络在学习过程中产生一定的偏见（2）噪声过多、标注有大量错误时，会导致神经网络难以学到有用的信息，从而出现摇摆不定的情况，（3）数据类别不均衡使得少数类别由于信息量不足，难以学到本质特征。
j 特征问题。特征选择不合理，会使网络学习难度增加。
**val loss不下降**
a 训练的时候过拟合导致效果不好
通过交叉检验得到较优的模型参数;
减少特征数或使用较少的特征组合，对于按区间离散化的特征，增大划分的区间;
常用的有 L1、L2 正则。而且 L1正则还可以自动进行特征选择;
增加训练数据可以有限的避免过拟合;
Bagging ,将多个弱学习器Bagging 一下效果会好很多，比如随机森林等.
早停策略。本质上是交叉验证策略，选择合适的训练次数，避免训练的网络过度拟合训练数据。
DropOut
b 应用场景不同导致。本来训练任务是分类猫和狗，测试用的皮卡丘和葫芦娃。
c 噪声问题。训练数据大概率都是经过去噪处理的，而真实测试时也应该去除噪声。
（3）网络训练结果
C:\ProgramData\Anaconda3\envs\python37-12deepnetwork\python.exe D:/mypathon3/deepnetwork/train.py
using cpu device.
Using 4 dataloader workers every process
using 3306 images for training, 364 images for validation.
train epoch[1/10] loss:1.435: 100%|██████████| 104/104 [06:42<00:00, 3.87s/it]（第一轮进度条显示训练过程）
402.981893866（第一轮训练的时间）
100%|██████████| 12/12 [00:40<00:00, 3.37s/it]
[epoch 1] train_loss: 1.358 val_accuracy: 0.478（第一轮结果）
train epoch[2/10] loss:1.315: 100%|██████████| 104/104 [05:43<00:00, 3.31s/it]
343.99045856
100%|██████████| 12/12 [00:36<00:00, 3.00s/it]
[epoch 2] train_loss: 1.172 val_accuracy: 0.549
train epoch[3/10] loss:1.176: 100%|██████████| 104/104 [05:35<00:00, 3.22s/it]
335.330872374
100%|██████████| 12/12 [00:37<00:00, 3.13s/it]
[epoch 3] train_loss: 1.085 val_accuracy: 0.621
train epoch[4/10] loss:1.177: 100%|██████████| 104/104 [05:34<00:00, 3.21s/it]
334.3210211569999
100%|██████████| 12/12 [00:37<00:00, 3.16s/it]
[epoch 4] train_loss: 1.007 val_accuracy: 0.624
train epoch[5/10] loss:1.184: 100%|██████████| 104/104 [05:39<00:00, 3.27s/it]
339.8078791549999
100%|██████████| 12/12 [00:35<00:00, 2.99s/it]
[epoch 5] train_loss: 0.947 val_accuracy: 0.665
train epoch[6/10] loss:1.216: 100%|██████████| 104/104 [05:38<00:00, 3.26s/it]
338.5817820459997
100%|██████████| 12/12 [1:44:55<00:00, 524.60s/it]
[epoch 6] train_loss: 0.916 val_accuracy: 0.662
train epoch[7/10] loss:0.831: 100%|██████████| 104/104 [05:14<00:00, 3.02s/it]
314.3709090400007
100%|██████████| 12/12 [00:37<00:00, 3.10s/it]
[epoch 7] train_loss: 0.899 val_accuracy: 0.681
train epoch[8/10] loss:0.975: 100%|██████████| 104/104 [05:28<00:00, 3.16s/it]
328.79853093100064
100%|██████████| 12/12 [00:38<00:00, 3.24s/it]
[epoch 8] train_loss: 0.875 val_accuracy: 0.690
train epoch[9/10] loss:0.662: 100%|██████████| 104/104 [05:39<00:00, 3.26s/it]
339.44431901499956
100%|██████████| 12/12 [00:39<00:00, 3.30s/it]
[epoch 9] train_loss: 0.855 val_accuracy: 0.703
train epoch[10/10] loss:0.661: 100%|██████████| 104/104 [7:34:05<00:00, 261.98s/it]
27254.444320990995
100%|██████████| 12/12 [00:40<00:00, 3.33s/it]
[epoch 10] train_loss: 0.825 val_accuracy: 0.725
Finished Training
Process finished with exit code 0
最后一轮的train_loss: 0.825，还在下降，应该还可以继续训练。但程序只统计了train_loss，而没有统计val_loss的变化情况。
网上下了一张图片进行测试，郁金香识别成了玫瑰。接下来将epochs提高到20再测试，郁金香识别正确， 但val_accuracy并没有提高多少。
9117
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
