多分类问题softmax的分类器
为什么要探索多分类
之前我们在处理糖尿病数据集的时候我们只是有两种分类，但是很多情况的数据集不只有两种，例如MNIST数据集就是手写数字的数据集有10种不同的标签。所以我们必须有处理多种分类标签的能力。
探索多分类
是否还可以使用二分类的操作？
当然还是可以使用二分类的方法来解决这个问题，某分类设置位p=1其他全部p=0就可以了，还是使用交叉熵损失函数来处理。


这里我们要注意到，我们的样本必须是只有一个选择的，所以我们的输出数据当中只能有一个输出的数据比较大，要对其他形成抑制，或者描述为所有的输出的和必须是1。但是我们使用上面的方法并不能满足，甚至所有的分类的输出都是0.8或0.9这种。

如果我们这样做呢？将十种输出的最后一种转化为1减去其他输出，这样是否可行呢？实际上也并不行，因为我们如果这样处理将会导致十种输出的结果过程并不相同，导致系统的并行能力下降，使得整体的效率下降。
那该怎么实现？
所以我们的输出应当是一个分布，我们前面的一些层还是可以使用sigmoid来做一个层，最后我们要用一个特殊层来完成一个将原有输出转化位一个分布的操作。

我们看一下我们需要做到什么内容：

1.输出的内容和是一个1 。

2.输出的内容都在0-1之间。

我们可以想到第一个内容比较好实现我们只需要让输出是一个分数就行了。分母设置成一样的内容，分子的和等于这个分母。这是十分容易的。

之后我们再来分析第二个，想要让输出是0-1，在我们已经做到第一个要求的情况下，我们想做到第二个，其实只需要所有的输出全部都是大于0的就可以完成了。这样我们就想到了一个东西指数函数，指数函数的值永远是大于0的。这样问题就解决了。

所以我们只需要使用一个softmax层，这个层的运算如下：


这样就可以完成我们的需求。

我们来看一个实际的例子就更好理解了：



这样我们就理解了softmax层
那么损失函数又该怎么做
我们实际上还是需要使用交叉熵损失函数，我们看一下交叉熵损失函数，其实是什么情况，我们知道交叉熵损失函数是根据其中的概率进行计算的，因为我们是打标签，除了1的就全是0所以我们需要计算的内容其实可以简化：

所以其实loss函数就发生了变化：



整体的情况就变成了如下的情况：



这个其实就是NLL损失函数：



这个是理论上的情况，但是我们在pytorch当中其实并没有这么复杂，我们可以直接使用交叉熵损失函数来将从softmax直接一下子全部包含了。注意我们最后一层是不需要使用激活的，最后一层其实是交叉熵损失函数直接替我们完成了这个操作。



这里一个关键是一定要区分清楚NLL损失和交叉熵损失。
图像张量的问题
如果一个灰度图就是一个单通道的图，我们平时看到的彩色图像其实是三通道（Channel）的RGB，所以我们在表示图像张量的时候一般是whc就是（宽度*高 *通道）

为什么我们要将数据转化位N（0，1）因为这种标准分布的数据对于神经网络来说是最好的，对于神经网络来说训练效果是最好的
什么时候进行transform的问题
我们实际上是将transform定义在了datasets的位置。使用的下面的代码：
trian_set = datasets.MNIST(root='./data',train=True,download=True,transform=transform)

我们注意这样子的一个问题，这个MNIST数据集毕竟是一个图片，其实占地方不小的，所以我们不能直接将其读入内存，所以我们不能读进来再transform，需要每次从文件读进来一个之后再进行transform。
构建神经网络
因为我们使用的是全连接神经网络，所以我们最后输入的一个数据应当是一个矩阵（二维的）但是我们这里的输入实际上是一个四维的输入，数据量*通道数*宽*高,所以我们要转化一下，这里就需要使用view函数了，具体使用下面的函数
x= x.view(-1,784)

之后我们画一个图，写模型就好写了


代码实现
import numpy
import torch
from torchvision import transforms
from torchvision import datasets
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import Dataset
from torch.utils.data import DataLoader

#这里我们要理解这个from的作用，使用一个from

#transeforms 主要是用来做图像处理
# optim主要是包含优化器的
#首先明白下面这个东西是个什么东西？
#这个东西是个转化器，可以对输入的内容做我们规定好的操作，
# 具体操作就是下面[]中定义的。
#这里注意一个细节transforms和transform的区别，带s的表示是一片，不带s的是一个，我们实例化的一个
batch_size=64
transform= transforms.Compose([
    #这个首先转化为一个张量
    transforms.ToTensor(),
    #为了更好的学习效果我们需要一个标准化的过程，前一个参数是均值后一个是方差
    # 这两个参数都是MNIST数据集使用的，如果是自己的数据集这个要算一下。
    transforms.Normalize((0.1307,),(0.3081,))
])
#这里其实和之前的一样的，只是加了一个transform=的参数
trian_set = datasets.MNIST(root='./data',train=True,download=True,transform=transform)
trian_loader= DataLoader(trian_set,shuffle=True,batch_size=batch_size)
test_set =datasets.MNIST(root='./data',train=False,download=True,transform=transform)
test_loader= DataLoader(test_set,shuffle=True,batch_size=batch_size)
class myModol(torch.nn.Module):
    def __init__(self):
        super(myModol,self).__init__()
        self.l1=torch.nn.Linear(784,512)
        self.l2=torch.nn.Linear(512,256)
        self.l3=torch.nn.Linear(256,128)
        self.l4=torch.nn.Linear(128,64)
        self.l5=torch.nn.Linear(64,10)
      
    def forward(self,x):
        #前面的-1代表着看着情况进行变化。
        #这里我们注意我们的这里输入的784不是随便输入的，
        # 是有实际意义的，MNIST的数据集的输入是1*28*28的，
        # 所以我们想要转化为二维的时候，一定要尊重原有的实际意义
        x=x.view(-1,784)
        x=F.relu(self.l1(x))
        x=F.relu(self.l2(x))
        x=F.relu(self.l3(x))
        x=F.relu(self.l4(x))
        return self.l5(x)
       #因为我们最后使用的是交叉熵损失函数已经将激活层抱进去了不用再单独写了
model=myModol()
#使用一个交叉熵损失函数
criterion=torch.nn.CrossEntropyLoss()
#因为我们计算量已经比较大了所以要使用一个带有冲量的优化器。
opminster= optim.SGD(model.parameters(),lr=0.01,momentum=0.5)
def train(epoch):
    train_loss=0.0
    for batch_idx,data in enumerate(trian_loader,0):
        m_input,target=data
        opminster.zero_grad()

        outputs= model(m_input)
        loss=criterion(outputs,target)
        loss.backward()
        opminster.step()

        train_loss+=loss.item()
        if batch_idx%300==299:
            #每300次才输出一次，另外因为我们都是从0开始计数所以我们需要+1
            print('[%d,%5d]loss:%.3f'%(epoch+1,batch_idx+1,train_loss/300))
            train_loss=0
def test():
    #定义几个计数变量
    correct=0
    total=0
    #因为我们在计算损失的时候是不需要进行梯度计算的，
    # 所以这里取消梯度计算来增加速度。
    with torch.no_grad():
        for data in test_loader:
            images,targets=data
            outputs=model(images)
            #这里我们注意我们在输出的时候是一个最大值，一个最大值角标，我们只需要最大值角标，
            # 这里我们注意dim=1的这个问题，dim=0代表每列找一个，dim=1代表每行找。
            _,predicted=torch.max(outputs.data,dim=1)
            #这里我们注意一个问题就是返回的形式是torch.Size，
            # 这个玩意是一个元组，这里是（行数，列数）所以我们要取出来第0个。
            total+=targets.size(0)
            #我们注意这里张量比较的使用问题
            correct+=(predicted==targets).sum().item()
    print('acc on test set:%d%%'%(100*correct/total))
if __name__=='__main__':
    for epoch in range(10):
        train(epoch)
        test()
#但是我们这里的全连接层得到的准确度并不高，因为我们是将图上的所有信息都全部利用了
#其实决定图片的数字到底是多少并不是由全部的情况决定的。

由于某些原因，回归和分类问题总会引起机器学习领域的大部分关注。多标签分类在数据科学中是一个比较令人头疼的问题。在这篇文章中，我将给你一个直观的解释，说明什么是多标签分类，以及如何解决这个问题。
1.多标签分类是什么?
让我们来看看下面的图片。
如果我问你这幅图中有一栋房子，你会怎样回答? 选项为“Yes”或“No”。
或者这样问，所有的东西(或标签)与这幅图有什么关系?
在这些类型的问题中，我们有一组目标变量，被称为多标签分类问题。那么，这两种情况有什么不同吗? 很明显，有很大的不同，因为在第二种情况下，任何图像都可能包含不同图像的多个不同的标签。
但在深入讲解多标签之前，我想解释一下它与多分类问题有何不同，让我们试着去理解这两组问题的不同之处。
2.多标签vs多分类
用一个例子来理解这两者之间的区别。
对于任何一部电影，电影的中央委员会会根据电影的内容颁发证书。例如，如果你看上面的图片，这部电影被评为“UA”(意思是“12岁以下儿童需在父母陪同下观看”)。还有其他类型的证书类，如“A”(仅限于成人)或“U”(不受限制的公开放映)，但可以肯定的是，每部电影只能在这三种类型的证书中进行分类。简而言之，有多个类别，但每个实例只分配一个，因此这些问题被称为多类分类问题。
同时，你回顾一下这张图片，这部电影被归类为喜剧和浪漫类型。但不同的是，这一次，每部电影都有可能被分成一个或多个不同的类别。
所以每个实例都可以使用多个类别进行分配。因此，这些类型的问题被称为多标签分类问题。
现在你应该可以区分多标签和多分类问题了。那么，让我们开始处理多标签这种类型的问题。
3.加载和生成多标签数据集
Scikit-learn提供了一个独立的库scikit-multilearn，用于多种标签分类。为了更好的理解，让我们开始在一个多标签的数据集上进行练习。scikit-multilearn库地址：http://scikit.ml/api/datasets.html
你可以从MULAN package提供的存储库中找到实际的数据集。这些数据集以ARFF格式呈现。存储库地址：http://mulan.sourceforge.net/datasets-mlc.html
因此，为了开始使用这些数据集，请查看下面的Python代码，将其加载到你的计算机上。在这里，我已经从存储库中下载了酵母(yeast)数据集。
import scipy
from scipy.io import arff
data, meta = scipy.io.arff.loadarff('/Users/shubhamjain/Documents/yeast/yeast-train.arff')
df = pd.DataFrame(data)
这就是数据集的样子。
在这里，Att表示属性或独立变量，class表示目标变量。
出于实践目的，我们有另一个选项来生成一个人工的多标签数据集。
from sklearn.datasets import make_multilabel_classification
# this will generate a random multi-label dataset
X, y = make_multilabel_classification(sparse = True, n_labels = 20,
return_indicator = 'sparse', allow_unlabeled = False)
让我们了解一下上面所使用的参数。
sparse(稀疏):如果是True，返回一个稀疏矩阵，稀疏矩阵表示一个有大量零元素的矩阵。
n_labels:每个实例的标签的平均数量。
return_indicator:“sparse”在稀疏的二进制指示器格式中返回Y。
allow_unlabeled:如果是True，有些实例可能不属于任何类。
你一定会注意到，我们到处都使用了稀疏矩阵，而scikit-multilearn也建议使用稀疏格式的数据，因为在实际数据集中非常罕见。一般来说，分配给每个实例的标签的数量要少得多。
好了，现在我们已经准备好了数据集，让我们快速学习解决多标签问题的技术。
4.解决多标签分类问题的技术
基本上，有三种方法来解决一个多标签分类问题，即:
问题转换
改编算法
集成方法
4.1问题转换
在这个方法中，我们将尝试把多标签问题转换为单标签问题。这种方法可以用三种不同的方式进行:
二元关联(Binary Relevance)
分类器链(Classifier Chains)
标签Powerset(Label Powerset)
4.4.1二元关联(Binary Relevance)
这是最简单的技术，它基本上把每个标签当作单独的一个类分类问题。例如，让我们考虑如下所示的一个案例。我们有这样的数据集，X是独立的特征，Y是目标变量。
在二元关联中，这个问题被分解成4个不同的类分类问题，如下图所示。
我们不需要手动操作，multi-learn库在python中提供了它的实现。那么，让我们看看它在随机生成的数据上的实现。
# using binary relevance
from skmultilearn.problem_transform import BinaryRelevance
from sklearn.naive_bayes import GaussianNB
# initialize binary relevance multi-label classifier
# with a gaussian naive bayes base classifier
classifier = BinaryRelevance(GaussianNB())
# train
classifier.fit(X_train, y_train)
# predict
predictions = classifier.predict(X_test)
注意:在这里，我们使用了Naive Bayes的算法，你也可以使用任何其他的分类算法。
现在，在一个多标签分类问题中，我们不能简单地用我们的标准来计算我们的预测的准确性。所以，我们将使用accuracy score。这个函数计算子集的精度，这意味着预测的标签集应该与真正的标签集完全匹配。
那么，让我们计算一下预测的准确性。
from sklearn.metrics import accuracy_score
accuracy_score(y_test,predictions)
0.45454545454545453
我们的准确率达到了45%，还不算太糟。它是最简单和有效的方法，但是这种方法的惟一缺点是它不考虑标签的相关性，因为它单独处理每个目标变量。
4.1.2分类器链(Classifier Chains)
在这种情况下，第一个分类器只在输入数据上进行训练，然后每个分类器都在输入空间和链上的所有之前的分类器上进行训练。
让我们试着通过一个例子来理解这个问题。在下面给出的数据集里，我们将X作为输入空间，而Y作为标签。
在分类器链中，这个问题将被转换成4个不同的标签问题，就像下面所示。黄色部分是输入空间，白色部分代表目标变量。
这与二元关联非常相似，唯一的区别在于它是为了保持标签相关性而形成的。那么，让我们尝试使用multi-learn库来实现它。
# using classifier chains
from skmultilearn.problem_transform import ClassifierChain
from sklearn.naive_bayes import GaussianNB
# initialize classifier chains multi-label classifier
# with a gaussian naive bayes base classifier
classifier = ClassifierChain(GaussianNB())
# train
classifier.fit(X_train, y_train)
# predict
predictions = classifier.predict(X_test)
accuracy_score(y_test,predictions)
0.21212121212121213
我们可以看到，使用这个我们得到了21%的准确率，这比二元关联要低得多。可能是因为没有标签相关性，因为我们已经随机生成了数据。
4.1.3标签Powerset(Label Powerset)
在这方面，我们将问题转化为一个多类问题，一个多类分类器在训练数据中发现的所有唯一的标签组合上被训练。让我们通过一个例子来理解它。
在这一点上，我们发现x1和x4有相同的标签。同样的，x3和x6有相同的标签。因此，标签powerset将这个问题转换为一个单一的多类问题，如下所示。
因此，标签powerset给训练集中的每一个可能的标签组合提供了一个独特的类。让我们看看它在Python中的实现。
# using Label Powerset
from skmultilearn.problem_transform import LabelPowerset
from sklearn.naive_bayes import GaussianNB
# initialize Label Powerset multi-label classifier
# with a gaussian naive bayes base classifier
classifier = LabelPowerset(GaussianNB())
# train
classifier.fit(X_train, y_train)
# predict
predictions = classifier.predict(X_test)
accuracy_score(y_test,predictions)
0.5757575757575758
这使我们在之前讨论过的三个问题中得到了最高的准确性，57%。唯一的缺点是随着训练数据的增加，类的数量也会增加。因此，增加了模型的复杂性，并降低了精确度。
现在，让我们看一下解决多标签分类问题的第二种方法。
4.2改编算法
改编算法来直接执行多标签分类，而不是将问题转化为不同的问题子集。例如，kNN的多标签版本是由MLkNN表示的。那么，让我们快速地在我们的随机生成的数据集上实现这个。
from skmultilearn.adapt import MLkNN
classifier = MLkNN(k=20)
# train
classifier.fit(X_train, y_train)
# predict
predictions = classifier.predict(X_test)
accuracy_score(y_test,predictions)
0.69
很好，你的测试数据已经达到了69%的准确率。
在一些算法中，例如随机森林(Random Forest)和岭回归(Ridge regression)，Sci-kit learn提供了多标签分类的内置支持。因此，你可以直接调用它们并预测输出。
4.3集成方法
集成总是能产生更好的效果。Scikit-Multilearn库提供不同的组合分类功能，你可以使用它来获得更好的结果。
5.案例研究
在现实世界中，多标签分类问题非常普遍。所以，来看看我们能在哪些领域找到它们。
5.1音频分类
我们知道歌曲会被分类为不同的流派。他们也被分类为，如“放松的平静”，或“悲伤的孤独”等等情感或情绪的基础。
5.2图像分类
使用图像的多标签分类也有广泛的应用。图像可以被标记为不同的对象、人或概念。
5.3生物信息学
多标签分类在生物信息学领域有很多用途，例如，在酵母数据集中的基因分类。它还被用来使用几个未标记的蛋白质来预测蛋白质的多重功能。
5.4文本分类
谷歌新闻所做的是，将每条新闻都标记为一个或多个类别，这样它就会显示在不同的类别之下。
例如，看看下面的图片。
同样的新闻出现在“Technology”,“Latest” 等类别中，因为它已经被分类为不同的标签。从而使其成为一个多标签分类问题。

什么是多标签分类

学习过机器学习的你，也许对分类问题很熟悉。比如下图：

 



image.png

图片中是否包含房子？你的回答就是有或者没有，这就是一个典型的二分类问题。

 



image.png

同样，是这幅照片，问题变成了，这幅照片是谁拍摄的？备选答案你，你的父亲，你的母亲？这就变成了一个多分类问题。



image.png

但今天谈论的多标签是什么呢？

如果我问你上面图包含一座房子吗？选项会是YES或NO。

 



image.png

你会发现图中所示的答案有多个yes，而不同于之前的多分类只有一个yes。

这里思考一下：

一首歌：如果你有四个类别的音乐，分别为：古典音乐、乡村音乐、摇滚乐和爵士乐，那么这些类别之间是互斥的。这首歌属于哪个类别？这是一个什么问题？

一首歌：如果你有四个类别的音乐，分别为：人声音乐、舞曲、影视原声、流行歌曲，那么这些类别之间并不是互斥的。这首歌属于哪个类别？这是一个什么问题？

多标签的问题的损失函数是什么

这里需要先了解一下softmax 与 sigmoid函数

 



image.png

这两个函数最重要的区别，我们观察一下：

 



image.png

区别还是很明显的。

综上，我们可以得出以下结论：

 



image.png

pytorch中的实现

PyTorch提供了两个类来计算二分类交叉熵（Binary Cross Entropy），分别是BCELoss() 和BCEWithLogitsLoss()

看一下源码，参考帮助，我们来玩一下

 



image.png

 

from torch import autograd
input = autograd.Variable(torch.randn(3,3), requires_grad=True)
print(input)


输出

 

tensor([[ 1.9072,  1.1079,  1.4906],
        [-0.6584, -0.0512,  0.7608],
        [-0.0614,  0.6583,  0.1095]], requires_grad=True)


因为Note that the targets t[i] should be numbers between 0 and 1.

所以需要先sigmoid

 

from torch import nn
m = nn.Sigmoid()
print(m(input))


输出

 

tensor([[0.8707, 0.7517, 0.8162],
        [0.3411, 0.4872, 0.6815],
        [0.4847, 0.6589, 0.5273]], grad_fn=<SigmoidBackward>)


假设你的target如下：

 

target = torch.FloatTensor([[0, 1, 1], [1, 1, 1], [0, 0, 0]])
print(target)


输出

 

tensor([[0., 1., 1.],
        [1., 1., 1.],
        [0., 0., 0.]])


 

 

我们先根据源码中公式，



image.png

 

自己计算一下：

 

import math

r11 = 0 * math.log(0.8707) + (1-0) * math.log((1 - 0.8707))
r12 = 1 * math.log(0.7517) + (1-1) * math.log((1 - 0.7517))
r13 = 1 * math.log(0.8162) + (1-1) * math.log((1 - 0.8162))

r21 = 1 * math.log(0.3411) + (1-1) * math.log((1 - 0.3411))
r22 = 1 * math.log(0.4872) + (1-1) * math.log((1 - 0.4872))
r23 = 1 * math.log(0.6815) + (1-1) * math.log((1 - 0.6815))

r31 = 0 * math.log(0.4847) + (1-0) * math.log((1 - 0.4847))
r32 = 0 * math.log(0.6589) + (1-0) * math.log((1 - 0.6589))
r33 = 0 * math.log(0.5273) + (1-0) * math.log((1 - 0.5273))

r1 = -(r11 + r12 + r13) / 3
#0.8447112733378236
r2 = -(r21 + r22 + r23) / 3
#0.7260397266631787
r3 = -(r31 + r32 + r33) / 3
#0.8292933181294807
bceloss = (r1 + r2 + r3) / 3 
print(bceloss)


输出

 

0.8000147727101611



核心解读

就是把每一个标签的预测值(sigmoid计算之后）交给cross_entropy函数来进行分类计算。比如样本1是一张图片(r1)，r11代表某一个标签（有房子），r12代表某一个标签（有树）， r13代表某一个标签（有小狗），最后r1就是样本1的预测值与真实值之间的loss。


我们再对比一下使用torch内置的loss函数

 

loss = nn.BCELoss()
print(loss(m(input), target))


输出

 

tensor(0.8000, grad_fn=<BinaryCrossEntropyBackward>)


和我们自己算的误差非常小，可以忽略。

我们可以把sigmoid和bce的过程放到一起，使用内建的BCEWithLogitsLoss函数

 

loss = nn.BCEWithLogitsLoss()
print(loss(input, target))


输出

 

tensor(0.8000, grad_fn=<BinaryCrossEntropyWithLogitsBackward>)




原帖：https://www.jianshu.com/p/ac3bec3dde3e

图像分类算法为什么有那么多？
AlexNet, VGGNet, MobileNet, ResNet, Inception v1 v2 v3 v4… blablabla为什么针对图像的分类算法有这么多，什么时候该用什么。 我好晕啊， 我觉得可能不止我一个人晕吧。

那就接着看吧。
这些算法的来源
首先事物都是有发展的过程的，图像分类算法也不例外，上面提到的和你听到的各种图像算法都是各位大佬为解决某一领域问题，在普通卷积思想的基础上发展出来的。 别慌，都是人想出来，不会很难。
为什么要有这么多不同的网络结构

不同的网络结构 解决的问题不同;
不同的网络结构 使用的技巧不同;

可喜的是，这些技巧除了在自身的网络上发挥作用，还可以用在其他网络结构上
不同的网络结构 应用的场景不同;

受限于不同的应用平台，PC端和移动端， 神经网络也需要经过裁剪，才能发挥它最大的作用

刚才说了，这些模型都是不断进化的结果，下图就是他们进化的时间线


接着我们看看各种网络都各自有什么特点吧
模型的进化
跟人的进化一样，人类进化时选择直起腰板走路、 选择切掉尾巴、 选择研究人工智能

图像分类算法选择向更深更宽进化

比如，AlexNet到VGGNet的过程中，神经网络变得更深更宽

因为在逐渐加宽加深神经网络模型时， 预测准确率直线上升
选择改变网络结构

当广度和深度都对准确率影响不大的时候，人们通过使用不同的模型结构，继续提高预测的准确率.

VGGNet到InceptionNet/ResNet发展期间，已经改变了原来常规卷积神经网络的网络结构。

常规的卷积神经网络的网络结构 = [卷积层 + (池化层)] * N +  全连接层 + 输出
VGGNet在每个卷积层后面继续加多个卷积层，结构 = [卷积层 * M + 池化层] * N +  全连接层 * Q + 输出
InceptionNet更是提出了分组卷积，改变了卷积层的结构

 普通卷积层总结


通过优势组合，继续进化

例如InceptionNet + ResNet 组合成了 InceptionResNet， 又将分类准确率的历史记录推高了一截.

在尝试不同的组合之后，找到几种在各自领域有优势的模型，组合使用


自我学习 NASNet

不再由人去指定模型的结构，让一种高级模型去自己学习出一种网络结构


向实用方向，朝着技术落地的目标努力

MobileNet就是这样一款针对移动端设计的神经网络结构


各模型的特点

AlexNet 该网络是深度学习的引爆点， 人工智能概念由此进入大众视野。 2012年由多伦多大学发表

	AlexNet 的网络结构特点
		5个卷积，3个全连接（2* 4096 +1000）
		多GPU并行化计算
		不同卷积层共享参数
		首次使用Relu
		1,2,5卷积层后跟随max-polling	
		两个全连接层上使用了Dropout


VGGNet 是较AlexNet更深的神经网络

	更多的使用3x3的卷积核，因为它认为
		2 个 3x3的卷积层 可以看做一格5x5的卷积层
		3 个 3x3的卷积层 可以看做一格7x7的卷积层
		而且，2层比1层多一次非线性变换，同时参数降低28% = （5*5 - 2*3*3） /（5*5）
	论文认为1x1的卷积层可以看做是非线性变化
	每经过一个pooling层，图像的通道的数目会翻倍

	先训练浅层网络如A， 再去训练深层网络
	多尺度输入
		不同的尺度训练多个分类器，然后做ensemble
		随机使用不同的尺度缩放然后输入进分类器进行训练
	但是网络结构再加深 效果提升不大 从而引出了ResNet
	模型深度达到某个程度后继续加深会导致训练集上准确率下降



ResNet残差网络(更深层网络)

	 这时发现一个问题，为什么在加深网络层数的后期，网络越深，训练集上错误率反而上升了， 这虽然是一个事实，但并不是说，深层次的网络学不到东西，只是更难优化
		因此论文提出一个想法： 通过加入一些恒等层，是的深度网络至少可以和浅层网络持平，
		y=x，虽然增加了深度，但误差不会增加

	网络结构：
		先用一个普通的卷积层， stride=2
		再经过一个3\*3的max-pooling
		各种残差网络的子结构
		没有中间的全连接层， 直接输出
	残差结构使得网络需要学习的知识变少，容易学习
	残差结构使得每一层的数据分布接近，容易学习



InceptionNet

	除了不断加宽加深神经网络，提高精度的这个方向外，
	还有一个方向就是InceptionNet， 由google提出，InceptionNet是一系列网络的总称

	InceptionNet同样能解决VGGNet网络层次加深，精度不提高的问题
	此外，InceptionNet还关注神经网络在工程方面的优化。--使得同样的参数量更有效率

	提出分组卷积概念：一层网络上同时使用多种卷积核，看到各种层级的feature。 不同组之间的feature不交叉计算，减少了计算量



MobileNet 引入深度可分离卷积