我認為深度學習用在嵌入式設備上也就兩條路，1：讓嵌入式設備更強大。2：讓算法更精簡。第一條路也就是各種加速卡或者專業(yè)設計的智能芯片?，F(xiàn)在越來越多這種芯片成熟了。第二條路也就是精簡（一般稱之為壓縮）算法的路子。我嘗試使用pytorch實現(xiàn)簡化版MobileNetv1。為什么是簡化版？因為我的GTX1060乞丐版還是不指望能訓練完整個imagenet（行文至此我突然發(fā)現(xiàn)我的Linux環(huán)境還沒裝cuda，暈），cifar-10的分辨率較小，適合我現(xiàn)在這種快速驗證的工作。為什么是MobileNetv1？因為相比其他幾個輕量級的網(wǎng)絡這個最簡單。廢話說多了，看一下MobileNetv1的結構和特點把。
MobileNetv1的結構在論文中介紹的很清楚。如下圖所示。
QQ截圖20190817220238.jpg
結合原文的3.2節(jié)，我認為其結構特點如下。
1.第一層依然為傳統(tǒng)的卷積結構
2.每一層后均使用batchnorm，激活函數(shù)均使用ReLU。
3.全連接層前用了一個平均池化層。
4.Depthwise Separable convolutions
Depthwise Separable convolutions 的結構論文中也進行了介紹，如下圖所示。
QQ截圖20190817220249.jpg
因此我認為通過更改一個現(xiàn)有CNN的結構可以很容易得到一個精簡MobileNet結構。
為了對比效果我使用一個簡單的兩層神經(jīng)網(wǎng)絡作為對比，并根據(jù)他進行修改。結構如下
self.conv1 = nn.Sequential(nn.Conv2d(3, 8, 5),\
nn.BatchNorm2d(8),\
nn.ReLU(),\
nn.MaxPool2d(2, 2))
self.conv2 = nn.Sequential(nn.Conv2d(8, 16, 5),\
nn.BatchNorm2d(16),\
nn.ReLU(),\
nn.MaxPool2d(2, 2),\
nn.Conv2d(16, 4, 1))
self.fc = nn.Linear(100, 10)
經(jīng)過測試，其能達到42%的正確率，有點低，不過作為一個cuda忘了裝的人來說這個計算量是我的CPU能扛得住的。
簡化為MobileNet，就是把第二層轉換為Depthwise Separable convolutions結構。更改后的結構如下
self.conv1 = nn.Sequential(nn.Conv2d(3, 8, 5),\
nn.BatchNorm2d(8),\
nn.ReLU(),\
nn.MaxPool2d(2, 2))
self.conv2 = nn.Sequential(nn.Conv2d(8, 8, 5),\
nn.BatchNorm2d(8),\
nn.ReLU(),\
nn.Conv2d(8, 16, 1),\
nn.BatchNorm2d(16),\
nn.ReLU(),\
nn.MaxPool2d(2, 2),\
nn.Conv2d(16, 4, 1))
self.fc = nn.Linear(100, 10)
最后一個平均池化層的效果不太好所以我換成了一個1*1的卷積層。完整代碼如下
# -*- coding: utf-8 -*-
"""
Created on Sun Aug 18 11:17:30 2019
@author: BHN
"""
import torch
import torchvision
import torchvision.transforms as transforms
transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
shuffle=True, num_workers=0)
testset = torchvision.datasets.CIFAR10(root='./data', train=False,
download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
shuffle=False, num_workers=0)
classes = ('plane', 'car', 'bird', 'cat',
'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
# self.conv1 = nn.Sequential(nn.Conv2d(3, 8, 5),\
# nn.BatchNorm2d(8),\
# nn.ReLU(),\
# nn.MaxPool2d(2, 2))
# self.conv2 = nn.Sequential(nn.Conv2d(8, 16, 5),\
# nn.BatchNorm2d(16),\
# nn.ReLU(),\
# nn.MaxPool2d(2, 2),\
# nn.Conv2d(16, 4, 1))
# self.fc = nn.Linear(100, 10)
self.conv1 = nn.Sequential(nn.Conv2d(3, 8, 5),\
nn.BatchNorm2d(8),\
nn.ReLU(),\
nn.MaxPool2d(2, 2))
self.conv2 = nn.Sequential(nn.Conv2d(8, 8, 5),\
nn.BatchNorm2d(8),\
nn.ReLU(),\
nn.Conv2d(8, 16, 1),\
nn.BatchNorm2d(16),\
nn.ReLU(),\
nn.MaxPool2d(2, 2),\
nn.Conv2d(16, 4, 1))
self.fc = nn.Linear(100, 10)
def forward(self, x):
x = self.conv1(x)
x = self.conv2(x)
# x = self.conv3(x)
# x = self.conv4(x)
# x = self.conv5(x)
# x = self.conv6(x)
x = x.view(-1, 100)
x = self.fc(x)
return x
net = Net()
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.RMSprop(net.parameters(), lr=0.001, momentum=0.9)
for epoch in range(2): # loop over the dataset multiple times
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
# get the inputs; data is a list of [inputs, labels]
inputs, labels = data
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = net(inputs)
# print(outputs.shape)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
if i % 2000 == 1999: # print every 2000 mini-batches
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 2000))
running_loss = 0.0
print('Finished Training')
dataiter = iter(testloader)
images, labels = dataiter.next()
outputs = net(images)
_, predicted = torch.max(outputs, 1)
print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
for j in range(4)))
correct = 0
total = 0
with torch.no_grad():
for data in testloader:
images, labels = data
outputs = net(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
print('Accuracy of the network on the 10000 test images: %d %%' % (
100 * correct / total))
正確率達到41%稍有下降，符合論文中在imagenet上的表現(xiàn)。
根據(jù)這個工具可以測出原始模型的flops和參數(shù)數(shù)量為：866566.0和4950.0。精簡MobileNetv1的為729766.0 和3502.0。可以發(fā)現(xiàn)有一定程度的減少，如果網(wǎng)絡規(guī)模更大，將減少更多。
經(jīng)過測試傳統(tǒng)的網(wǎng)絡結構測試所有測試集的時間為8.88390240000001秒：精簡MobileNetv1的測試時間為8.6628881秒，相差的不多，比Roof-line模型分析得到的差距要小。所以有時候理論和實際的差距還是有點大的。更詳細的代碼可以參考這位大神的代碼
總結：
MobileNet確實能在正確率下降不多的情況下降低計算量和參數(shù)量，但是經(jīng)過實際測試，下降的程度沒有理論計算出的值高。
