第5周学习：ShuffleNet & EfficientNet & 迁移学习

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

一、ShuffleNet V1

   连续的 group 卷积会产生边界效应，即某个输出channel仅仅来自输入channel的一小部分。这样学出来的特征会非常局限。于是就有了channel shuffle来解决这个问题如图 b 所示，在第二个 group 之前，将一个组内分成不同的子组，然后让子组分别与各组进行卷积。或者像图 c 所示，在进入第二个 group 卷积之前先对目前的组进行重组，即channel shuffle。这样每次组卷积对应的channel就不再局限了。

   ShuffleNet的核心就是用 PointWise Group Convolution，Channel Shuffle和DepthWise Separable Convolution代替ResNet block的相应层构成了ShuffleNet uint，达到了减少计算量和提高准确率的目的。channel shuffle解决了多个group convolution叠加出现的边界效应，PointWise Group Convolution和Depthwise Separable Convolution主要减少了计算量。

ShuffleNet结构：

二、ShuffleNet V2

ShuffleNet v2进行了四项实验，得出了一些比较耗时的操作，经过原理分析，提出了四条设计原则。

1. 卷积层输入输出通道数相同时，MAC最小

2. 分组卷积的分组数越大，MAC越大

3. 网络支路会降低模型的并行度

4. Element-wise操作不可忽视

结构：

   图a为shuffleNet v1正常Unit, 图b为shuffleNet v1降采样Unit，图c为shuffleNet v2 正常Unit, 图d为shuffleNet v2 降采样Unit.
   在shuffleNet v2中引入了Channel Split, 将通道数分为c’ 和c - c’，这里c’取c/2。一部分进行卷积操作，另一部分直接进行concat。卷积的那一路的输入和输出相等，这是考虑到第一条原则。两个1x1卷积不再进行分组，一部分原因是第二条原则，另一部分是因为Channel split就相当于是分组了。两路进行concat后，再进行Channel Shuffle，这是为了通道上的信息进行流动。否则，左端那路的一半通道信息将一直进行到后面都没有通过卷积层。
   对于空间降采样层，这个Unit是没有Channel split，这样可以实现在两路concat后，通道数翻倍。其余改动具体看图更容易理解。

网络结构：

   结构跟shuffleNet v1基本一致，唯一的差别是在全局平均池化前加入了1x1卷积，以便混合特征。右边的output channels下的0.5x, 1x等，只是用来表示不同的模型尺寸，也就是通道数不一样。

三、EfficientNet

卷积神经网络精度提升的经验：
1、网络深度的增加，典型的如resnet,就是通过残差网络的堆叠，增加网络层数，以此来提升精度。
2、网络宽度的增加，通过增加每层网络的特征层数，提取更多的特征，以此来提升精度。
3、图像分辨率的增加，分辨率越高的图像，所能获取的信息越多，网络能够学习到更多的特征，从而提升精度。

EfficientNet特点：
历史的实验经验表明，对于卷积神经网络的提升，着重点在于网络深度，网络宽度，分辨率这三个维度。因此，efficientnet应运而生，efficientnet结合了这三个优点，很好的平衡深度、宽度和分辨率这三个维度，通过一组固定的缩放系数统一缩放这三个维度。

EfficientNet和其他网络的比较，我们可以看出EfficientNet相对于其他网络，有了质的突破：

网络结构：

EfficientNet使用了MobileNet V2中的MBCConv作为模型的主干网络，同时也是用了SENet中的squeeze and excitation方法对网络结构进行了优化。

SEnet模块：

SE模块由一个全局平均池化，两个全连接层组成。第一个全连接层的节点个数是输入该MBConv特征矩阵channels的1/4，且使用Swish激活函数。第二个全连接层的节点个数等于Depthwise Conv层输出的特征矩阵channels，且使用Sigmoid激活函数。

四、使用VGG模型进行猫狗大战

下载数据：

! wget http://fenggao-image.stor.sinaapp.com/dogscats.zip
! unzip dogscats.zip

创建 VGG Model：

model_vgg = models.vgg16(pretrained=True)

with open('./imagenet_class_index.json') as f:
    class_dict = json.load(f)
dic_imagenet = [class_dict[str(i)][1] for i in range(len(class_dict))]

inputs_try , labels_try = inputs_try.to(device), labels_try.to(device)
model_vgg = model_vgg.to(device)

outputs_try = model_vgg(inputs_try)

print(outputs_try)
print(outputs_try.shape)
m_softm = nn.Softmax(dim=1)
probs = m_softm(outputs_try)
vals_try,pred_try = torch.max(probs,dim=1)

print( 'prob sum: ', torch.sum(probs,1))
print( 'vals_try: ', vals_try)
print( 'pred_try: ', pred_try)

print([dic_imagenet[i] for i in pred_try.data])
imshow(torchvision.utils.make_grid(inputs_try.data.cpu()), 
       title=[dset_classes[x] for x in labels_try.data.cpu()])

我们的目标是使用预训练好的模型，因此，需要把最后的 nn.Linear 层由1000类，替换为2类。为了在训练中冻结前面层的参数，需要设置 required_grad=False。这样，反向传播训练梯度时，前面层的权重就不会自动更新了。训练中，只会更新最后一层的参数。

print(model_vgg)

model_vgg_new = model_vgg;

for param in model_vgg_new.parameters():
    param.requires_grad = False
model_vgg_new.classifier._modules['6'] = nn.Linear(4096, 2)
model_vgg_new.classifier._modules['7'] = torch.nn.LogSoftmax(dim = 1)

model_vgg_new = model_vgg_new.to(device)

print(model_vgg_new.classifier)

训练并测试全连接层，包括三个步骤：第1步，创建损失函数和优化器；第2步，训练模型；第3步，测试模型。

criterion = nn.NLLLoss()

# 学习率
lr = 0.001

# 随机梯度下降
optimizer_vgg = torch.optim.SGD(model_vgg_new.classifier[6].parameters(),lr = lr)

def train_model(model,dataloader,size,epochs=1,optimizer=None):
    model.train()
    
    for epoch in range(epochs):
        running_loss = 0.0
        running_corrects = 0
        count = 0
        for inputs,classes in dataloader:
            inputs = inputs.to(device)
            classes = classes.to(device)
            outputs = model(inputs)
            loss = criterion(outputs,classes)           
            optimizer = optimizer
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            _,preds = torch.max(outputs.data,1)
            # statistics
            running_loss += loss.data.item()
            running_corrects += torch.sum(preds == classes.data)
            count += len(inputs)
            print('Training: No. ', count, ' process ... total: ', size)
        epoch_loss = running_loss / size
        epoch_acc = running_corrects.data.item() / size
        print('Loss: {:.4f} Acc: {:.4f}'.format(
                     epoch_loss, epoch_acc))
        
train_model(model_vgg_new,loader_train,size=dset_sizes['train'], epochs=1, 
            optimizer=optimizer_vgg)  

可视化模型预测结果（主观分析）

# 单次可视化显示的图片个数
n_view = 8
correct = np.where(predictions==all_classes)[0]
from numpy.random import random, permutation
idx = permutation(correct)[:n_view]
print('random correct idx: ', idx)
loader_correct = torch.utils.data.DataLoader([dsets['valid'][x] for x in idx],
                  batch_size = n_view,shuffle=True)
for data in loader_correct:
    inputs_cor,labels_cor = data
# Make a grid from batch
out = torchvision.utils.make_grid(inputs_cor)
imshow(out, title=[l.item() for l in labels_cor])