卷积神经网络(CNN)

模仿人眼的一个局部相关性、局部感受的机制（感受野），提出的网络叫做卷积神经网络，每次感受一个小的方块（视野），窗口方块移动时，权值是共享的。
卷积神经网络中的权值共享，类似于滤波操作，就是整张图片在使用同一个卷积核内的参数，比如一个3×3×1的卷积核，这个卷积核9个参数被整张图共享，而不会因为图像内位置的不同而改变卷积核内的权系数，这大大减少了卷积核中的参数量，此外因为权值共享后意味着每个卷积和只能提取到一种特征，为了增加cnn的表达能力，当然需要多个核。

常见卷积操作和概念

1. upsample(向上采样)

 from torch.nn import functional as F
 ＃(1,16,14,14)-->(1,16,28,28)
 out= F.interpolate(x,scale_factor=2, mode='nearest') 

2. pooling层(池化)

下采样：略

3. BatchNorm

目的：避免出现梯度离散的现象
操作：通过feature scaling将特征数据进行归一化缩放，对于[b,c,h,w]的batch数据，将生成[c]维的数据，可以用在image Normalization和Batch Normalization中
优点：收敛更快；更好的性能；更具有鲁棒性


算法步骤：

代码使用：

x=torch.rand(1,16,7,7)
layer=nn.BatchNorm2d(16)
out=layer(x)
layer.running_mean #代表归一化后，数据的均值
layer.running_var #代表归一化后，数据的方差
layer.weight #代表γ
layer.bias  #代表β
vars(layer) #查看网络的信息
#换成test模式
layer.eval()
BatchNorm2d(16,eps=1e-05,momentum=0.1,affine=True,track_running_stats=True) #affine表示是否使用γ，β，

4. 数据增强

获得更多的采样数据；提高数据的多样性
常见的数据增强的手段

• flip(翻转)
• rotate(旋转)
• random Move & Crop(随机的移动、裁剪和缩放)
• GAN(对抗网络生成)

train_loader = torch.utils.data.DataLoader(
    datasets.MNIST('../data', train=True, download=True,
                   transform=transforms.Compose([
                       transforms.RandomHorizontalFlip(),
                       transforms.RandomVerticalFlip(),
                       transforms.RandomRotation(15),
                       transforms.RandomRotation([90, 180, 270]),
                       transforms.Resize([32, 32]),
                       transforms.RandomCrop([28, 28]),
                       transforms.ToTensor(),
                       # transforms.Normalize((0.1307,), (0.3081,))
                   ])),
    batch_size=batch_size, shuffle=True)

torchvision中提供了一个transform的操作，用来对数据做变换并打包

---

经典的网络架构

1. AlexNet(2012,8层)

• 在ImageNet挑战赛上，将错误率降了10个百分点，吸引了众多学者的关注，深度学习开始"爆发"
• 创新的使用了pooling 、ReLU、Dropout正则化

2. VGG(2014,11/16/19层)

• 探索出卷积小窗口(33)比大窗口(33)效果更好，参数更少
• 1*1的卷积能实现维度的改变

3. GoogLeNet(2014,22层)

• 创新的提出在同一层上用不同的卷积核，再进行concatenate聚合
  

后来人们发现不是层数越深越好，越深越难训练

4. ResNet——深度残差网络(何凯明，2015，152层)

• 目前非常著名且有用的网络
• 深层网络容易出现梯度离散(梯度变化近乎于0)，故而提出了shortcut----短路层连接使网络有一个选择权，可以自己选择去变成浅层或深层网络，同时极大的减少了内存占用，也使训练更加简单，网络单元例子如下：
  
  代码实践：

class ResBlk(nn.Module):
    def __init__(self, ch_in, ch_out):
        super(ResBlk, self).__init__()
        self.conv1 = nn.Conv2d(ch_in, ch_out, kernel_size=3, stride=1, padding=1)
        self.bn1 = nn.BatchNorm2d(ch_out)
        self.conv2 = nn.Conv2d(ch_out, ch_out, kernel_size=3, stride=1, padding=1)
        self.bn2 = nn.BatchNorm2d(ch_out)
        self.extra = nn.Sequential()
        if ch_out != ch_in:
            self.extra = nn.Sequential(
                nn.Conv2d(ch_in, ch_out, kernel_size=1, stride=1),
                nn.BatchNorm2d(ch_out)
            )

---

CNN网络实践

class Lenet5(nn.Module):
    def __init__(self):
        super(Lenet5,self).__init__()
        self.conv_unit=nn.Sequential(
            nn.Conv2d(3,16,kernel_size=5,stride=1,padding=0),  # in 3, out 16
            nn.MaxPool2d(kernel_size=2,stride=2,padding=0),
            nn.Conv2d(16,32,kernel_size=5,stride=1,padding=0),
            nn.MaxPool2d(kernel_size=2,stride=2,padding=0),
        )
        self.fc_unit=nn.Sequential(
            nn.Linear(32*5*5,32),
            nn.ReLU(),
            nn.Linear(32,10)
        )
    
    def forward(self,x):
        batchsz=x.size(0)
        x=self.conv_unit(x)
        x=x.view(batchsz,-1)
        logits=self.fc_unit(x)
        return logits

def main():
    batchsz=128
    cifar_train = datasets.CIFAR10('cifar',True,transform=transforms.Compose([
        transforms.Resize((32,32)),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485,0.456,0.456],std=[0.229,0.224,0.225])
    ]),download=True)
    cifar_train=DataLoader(cifar_train,batch_size=batchsz,shuffle=True)

    cifar_test = datasets.CIFAR10('cifar',False,transform=transforms.Compose([
        transforms.Resize((32,32)),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485,0.456,0.456],std=[0.229,0.224,0.225])
    ]),download=True)
    cifar_test=DataLoader(cifar_test,batch_size=batchsz,shuffle=True)
    
    device=torch.device('cuda')
    model=Lenet5().to(device)
    criteon=nn.CrossEntropyLoss().to(device)
    optimizer=optim.Adam(model.parameters(),lr=1e-3)
    print(model)

    for epoch in range(100):
        model.train()
        for batchidx,(x,label) in enumerate(cifar_train):
            x,label=x.to(device),label.to(device)
            logits=model(x)
            loss=criteon(logits,label)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
        
        model.eval()  #网络切换至test模式
        with torch.no_grad():  #不计算梯度
            total_correct=0
            total_num=0
            for x,label in cifar_test:
                x,label=x.to(device),label.to(device)
                logits=model(x)
                pred=logits.argmax(dim=1)
                correct=torch.eq(pred,label).float().sum().item()
                total_correct+=correct
                total_num+=x.size(0)
            acc=total_correct/total_num
            print(epoch,'test acc:',acc)