【深度學習系列】卷積神經網絡CNN原理詳解(一)——基本原理

　　上篇文章我們給出了用paddlepaddle來做手寫數字識別的示例，並對網絡結構進行到了調整，提高了識別的精度。有的同學表示不是很理解原理，為什么傳統的機器學習算法，簡單的神經網絡(如多層感知機)都可以識別手寫數字，我們要采用卷積神經網絡CNN來進行別呢？CNN到底是怎么識別的？用CNN有哪些優勢呢？我們下面就來簡單分析一下。在講CNN之前，為避免完全零基礎的人看不懂后面的講解，我們先簡單回顧一下傳統的神經網絡的基本知識。

---

 

　　神經網絡的預備知識

     為什么要用神經網絡？

• 特征提取的高效性。

 　　大家可能會疑惑，對於同一個分類任務，我們可以用機器學習的算法來做，為什么要用神經網絡呢？大家回顧一下，一個分類任務，我們在用機器學習算法來做時，首先要明確feature和label，然后把這個數據"灌"到算法里去訓練，最后保存模型，再來預測分類的准確性。但是這就有個問題，即我們需要實現確定好特征，每一個特征即為一個維度，特征數目過少，我們可能無法精確的分類出來，即我們所說的欠擬合，如果特征數目過多，可能會導致我們在分類過程中過於注重某個特征導致分類錯誤，即過擬合。

　　舉個簡單的例子，現在有一堆數據集，讓我們分類出西瓜和冬瓜，如果只有兩個特征：形狀和顏色，可能沒法分區來；如果特征的維度有：形狀、顏色、瓜瓤顏色、瓜皮的花紋等等，可能很容易分類出來；如果我們的特征是：形狀、顏色、瓜瓤顏色、瓜皮花紋、瓜蒂、瓜籽的數量，瓜籽的顏色、瓜籽的大小、瓜籽的分布情況、瓜籽的XXX等等，很有可能會過擬合，譬如有的冬瓜的瓜籽數量和西瓜的類似，模型訓練后這類特征的權重較高，就很容易分錯。這就導致我們在特征工程上需要花很多時間和精力，才能使模型訓練得到一個好的效果。然而神經網絡的出現使我們不需要做大量的特征工程，譬如提前設計好特征的內容或者說特征的數量等等，我們可以直接把數據灌進去，讓它自己訓練，自我“修正”，即可得到一個較好的效果。

• 數據格式的簡易性

　　在一個傳統的機器學習分類問題中，我們“灌”進去的數據是不能直接灌進去的，需要對數據進行一些處理，譬如量綱的歸一化，格式的轉化等等，不過在神經網絡里我們不需要額外的對數據做過多的處理，具體原因可以看后面的詳細推導。

• 參數數目的少量性

　　在面對一個分類問題時，如果用SVM來做，我們需要調整的參數需要調整核函數，懲罰因子，松弛變量等等，不同的參數組合對於模型的效果也不一樣，想要迅速而又准確的調到最適合模型的參數需要對背后理論知識的深入了解(當然，如果你說全部都試一遍也是可以的，但是花的時間可能會更多),對於一個基本的三層神經網絡來說(輸入-隱含-輸出)，我們只需要初始化時給每一個神經元上隨機的賦予一個權重w和偏置項b，在訓練過程中，這兩個參數會不斷的修正，調整到最優質，使模型的誤差最小。所以從這個角度來看，我們對於調參的背后理論知識並不需要過於精通(只不過做多了之后可能會有一些經驗，在初始值時賦予的值更科學，收斂的更快罷了)

   有哪些應用？

　　應用非常廣，不過大家注意一點，我們現在所說的神經網絡，並不能稱之為深度學習，神經網絡很早就出現了，只不過現在因為不斷的加深了網絡層，復雜化了網絡結構，才成為深度學習，並在圖像識別、圖像檢測、語音識別等等方面取得了不錯的效果。

    基本網絡結構

　　一個神經網絡最簡單的結構包括輸入層、隱含層和輸出層，每一層網絡有多個神經元，上一層的神經元通過激活函數映射到下一層神經元，每個神經元之間有相對應的權值，輸出即為我們的分類類別。

　詳細數學推導

　　去年中旬我參考吳恩達的UFLDL和mattmazur的博客寫了篇文章詳細講解了一個最簡單的神經網絡從前向傳播到反向傳播的直觀推導，大家可以先看看這篇文章--一文弄懂神經網絡中的反向傳播法--BackPropagation。

　優缺點

　　前面說了很多優點，這里就不多說了，簡單說說缺點吧。我們試想一下如果加深我們的網絡層，每一個網絡層增加神經元的數量，那么參數的個數將是M*N（m為網絡層數，N為每層神經元個數），所需的參數會非常多，參數一多，模型就復雜了，越是復雜的模型就越不好調參，也越容易過擬合。此外我們從神經網絡的反向傳播的過程來看，梯度在反向傳播時，不斷的迭代會導致梯度越來越小，即梯度消失的情況，梯度一旦趨於0，那么權值就無法更新，這個神經元相當於是不起作用了，也就很難導致收斂。尤其是在圖像領域，用最基本的神經網絡，是不太合適的。后面我們會詳細講講為啥不合適。

 

---

　　為什么要用卷積神經網絡？

　  傳統神經網絡的劣勢

　　前面說到在圖像領域，用傳統的神經網絡並不合適。我們知道，圖像是由一個個像素點構成，每個像素點有三個通道，分別代表RGB顏色，那么，如果一個圖像的尺寸是（28，28，1），即代表這個圖像的是一個長寬均為28，channel為1的圖像（channel也叫depth,此處1代表灰色圖像）。如果使用全連接的網絡結構，即，網絡中的神經與與相鄰層上的每個神經元均連接，那就意味着我們的網絡有28 * 28 =784個神經元，hidden層采用了15個神經元，那么簡單計算一下，我們需要的參數個數(w和b)就有：784*15*10+15+10=117625個，這個參數太多了，隨便進行一次反向傳播計算量都是巨大的，從計算資源和調參的角度都不建議用傳統的神經網絡。(評論中有同學對這個參數計算不太理解，我簡單說一下：圖片是由像素點組成的，用矩陣表示的，28*28的矩陣，肯定是沒法直接放到神經元里的，我們得把它“拍平”，變成一個28*28=784 的一列向量，這一列向量和隱含層的15個神經元連接，就有784*15=11760個權重w，隱含層和最后的輸出層的10個神經元連接，就有11760*10=117600個權重w，再加上隱含層的偏置項15個和輸出層的偏置項10個，就是：117625個參數了)

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　圖1 三層神經網絡識別手寫數字

　　

　　卷積神經網絡是什么？

　　三個基本層

•  卷積層（Convolutional Layer）

　　上文提到我們用傳統的三層神經網絡需要大量的參數，原因在於每個神經元都和相鄰層的神經元相連接，但是思考一下，這種連接方式是必須的嗎？全連接層的方式對於圖像數據來說似乎顯得不這么友好，因為圖像本身具有“二維空間特征”，通俗點說就是局部特性。譬如我們看一張貓的圖片，可能看到貓的眼鏡或者嘴巴就知道這是張貓片，而不需要說每個部分都看完了才知道，啊，原來這個是貓啊。所以如果我們可以用某種方式對一張圖片的某個典型特征識別，那么這張圖片的類別也就知道了。這個時候就產生了卷積的概念。舉個例子，現在有一個4*4的圖像，我們設計兩個卷積核，看看運用卷積核后圖片會變成什么樣。

 圖2　4*4 image與兩個2*2的卷積核操作結果

 

　　由上圖可以看到，原始圖片是一張灰度圖片,每個位置表示的是像素值，0表示白色，1表示黑色，（0，1）區間的數值表示灰色。對於這個4*4的圖像，我們采用兩個2*2的卷積核來計算。設定步長為1，即每次以2*2的固定窗口往右滑動一個單位。以第一個卷積核filter1為例，計算過程如下：

 

feature_map1(1,1) = 1*1 + 0*(-1) + 1*1 + 1*(-1) = 1 
feature_map1(1,2) = 0*1 + 1*(-1) + 1*1 + 1*(-1) = -1 
``` 4 feature_map1(3,3) = 1*1 + 0*(-1) + 1*1 + 0*(-1) = 2

 

　　可以看到這就是最簡單的內積公式。feature_map1(1,1)表示在通過第一個卷積核計算完后得到的feature_map的第一行第一列的值，隨着卷積核的窗口不斷的滑動，我們可以計算出一個3*3的feature_map1;同理可以計算通過第二個卷積核進行卷積運算后的feature_map2，那么這一層卷積操作就完成了。feature_map尺寸計算公式：[ (原圖片尺寸 -卷積核尺寸)/ 步長 ] + 1。這一層我們設定了兩個2*2的卷積核，在paddlepaddle里是這樣定義的：

conv_pool_1 = paddle.networks.simple_img_conv_pool(
        input=img,
        filter_size=3,
        num_filters=2,
        num_channel=1,
        pool_stride=1,
        act=paddle.activation.Relu())

　　這里調用了networks里simple_img_conv_pool函數，激活函數是Relu(修正線性單元)，我們來看一看源碼里外層接口是如何定義的：

def simple_img_conv_pool(input,
                         filter_size,
                         num_filters,
                         pool_size,
                         name=None,
                         pool_type=None,
                         act=None,
                         groups=1,
                         conv_stride=1,
                         conv_padding=0,
                         bias_attr=None,
                         num_channel=None,
                         param_attr=None,
                         shared_bias=True,
                         conv_layer_attr=None,
                         pool_stride=1,
                         pool_padding=0,
                         pool_layer_attr=None):
    """
    Simple image convolution and pooling group.
    Img input => Conv => Pooling => Output.
    :param name: group name.
    :type name: basestring
    :param input: input layer.
    :type input: LayerOutput
    :param filter_size: see img_conv_layer for details.
    :type filter_size: int
    :param num_filters: see img_conv_layer for details.
    :type num_filters: int
    :param pool_size: see img_pool_layer for details.
    :type pool_size: int
    :param pool_type: see img_pool_layer for details.
    :type pool_type: BasePoolingType
    :param act: see img_conv_layer for details.
    :type act: BaseActivation
    :param groups: see img_conv_layer for details.
    :type groups: int
    :param conv_stride: see img_conv_layer for details.
    :type conv_stride: int
    :param conv_padding: see img_conv_layer for details.
    :type conv_padding: int
    :param bias_attr: see img_conv_layer for details.
    :type bias_attr: ParameterAttribute
    :param num_channel: see img_conv_layer for details.
    :type num_channel: int
    :param param_attr: see img_conv_layer for details.
    :type param_attr: ParameterAttribute
    :param shared_bias: see img_conv_layer for details.
    :type shared_bias: bool
    :param conv_layer_attr: see img_conv_layer for details.
    :type conv_layer_attr: ExtraLayerAttribute
    :param pool_stride: see img_pool_layer for details.
    :type pool_stride: int
    :param pool_padding: see img_pool_layer for details.
    :type pool_padding: int
    :param pool_layer_attr: see img_pool_layer for details.
    :type pool_layer_attr: ExtraLayerAttribute
    :return: layer's output
    :rtype: LayerOutput
    """
    _conv_ = img_conv_layer(
        name="%s_conv" % name,
        input=input,
        filter_size=filter_size,
        num_filters=num_filters,
        num_channels=num_channel,
        act=act,
        groups=groups,
        stride=conv_stride,
        padding=conv_padding,
        bias_attr=bias_attr,
        param_attr=param_attr,
        shared_biases=shared_bias,
        layer_attr=conv_layer_attr)
    return img_pool_layer(
        name="%s_pool" % name,
        input=_conv_,
        pool_size=pool_size,
        pool_type=pool_type,
        stride=pool_stride,
        padding=pool_padding,
        layer_attr=pool_layer_attr)

　　我們在Paddle/python/paddle/v2/framework/nets.py 里可以看到simple_img_conv_pool這個函數的定義：

 

def simple_img_conv_pool(input,
                         num_filters,
                         filter_size,
                         pool_size,
                         pool_stride,
                         act,
                         pool_type='max',
                         main_program=None,
                         startup_program=None):
    conv_out = layers.conv2d(
        input=input,
        num_filters=num_filters,
        filter_size=filter_size,
        act=act,
        main_program=main_program,
        startup_program=startup_program)

    pool_out = layers.pool2d(
        input=conv_out,
        pool_size=pool_size,
        pool_type=pool_type,
        pool_stride=pool_stride,
        main_program=main_program,
        startup_program=startup_program)
    return pool_out

 

　　可以看到這里面有兩個輸出，conv_out是卷積輸出值，pool_out是池化輸出值，最后只返回池化輸出的值。conv_out和pool_out分別又調用了layers.py的conv2d和pool2d，去layers.py里我們可以看到conv2d和pool2d是如何實現的：

　　conv2d:

def conv2d(input,
           num_filters,
           name=None,
           filter_size=[1, 1],
           act=None,
           groups=None,
           stride=[1, 1],
           padding=None,
           bias_attr=None,
           param_attr=None,
           main_program=None,
           startup_program=None):
    helper = LayerHelper('conv2d', **locals())
    dtype = helper.input_dtype()

    num_channels = input.shape[1]
    if groups is None:
        num_filter_channels = num_channels
    else:
        if num_channels % groups is not 0:
            raise ValueError("num_channels must be divisible by groups.")
        num_filter_channels = num_channels / groups

    if isinstance(filter_size, int):
        filter_size = [filter_size, filter_size]
    if isinstance(stride, int):
        stride = [stride, stride]
    if isinstance(padding, int):
        padding = [padding, padding]

    input_shape = input.shape
    filter_shape = [num_filters, num_filter_channels] + filter_size

    std = (2.0 / (filter_size[0]**2 * num_channels))**0.5
    filter = helper.create_parameter(
        attr=helper.param_attr,
        shape=filter_shape,
        dtype=dtype,
        initializer=NormalInitializer(0.0, std, 0))
    pre_bias = helper.create_tmp_variable(dtype)

    helper.append_op(
        type='conv2d',
        inputs={
            'Input': input,
            'Filter': filter,
        },
        outputs={"Output": pre_bias},
        attrs={'strides': stride,
               'paddings': padding,
               'groups': groups})

    pre_act = helper.append_bias_op(pre_bias, 1)

    return helper.append_activation(pre_act)

　　pool2d:

def pool2d(input,
           pool_size,
           pool_type,
           pool_stride=[1, 1],
           pool_padding=[0, 0],
           global_pooling=False,
           main_program=None,
           startup_program=None):
    if pool_type not in ["max", "avg"]:
        raise ValueError(
            "Unknown pool_type: '%s'. It can only be 'max' or 'avg'.",
            str(pool_type))
    if isinstance(pool_size, int):
        pool_size = [pool_size, pool_size]
    if isinstance(pool_stride, int):
        pool_stride = [pool_stride, pool_stride]
    if isinstance(pool_padding, int):
        pool_padding = [pool_padding, pool_padding]

    helper = LayerHelper('pool2d', **locals())
    dtype = helper.input_dtype()
    pool_out = helper.create_tmp_variable(dtype)

    helper.append_op(
        type="pool2d",
        inputs={"X": input},
        outputs={"Out": pool_out},
        attrs={
            "poolingType": pool_type,
            "ksize": pool_size,
            "globalPooling": global_pooling,
            "strides": pool_stride,
            "paddings": pool_padding
        })

    return pool_out

　　大家可以看到，具體的實現方式還調用了layers_helper.py:

import copy
import itertools

from paddle.v2.framework.framework import Variable, g_main_program, \
    g_startup_program, unique_name, Program
from paddle.v2.framework.initializer import ConstantInitializer, \
    UniformInitializer


class LayerHelper(object):
    def __init__(self, layer_type, **kwargs):
        self.kwargs = kwargs
        self.layer_type = layer_type
        name = self.kwargs.get('name', None)
        if name is None:
            self.kwargs['name'] = unique_name(self.layer_type)

    @property
    def name(self):
        return self.kwargs['name']

    @property
    def main_program(self):
        prog = self.kwargs.get('main_program', None)
        if prog is None:
            return g_main_program
        else:
            return prog

    @property
    def startup_program(self):
        prog = self.kwargs.get('startup_program', None)
        if prog is None:
            return g_startup_program
        else:
            return prog

    def append_op(self, *args, **kwargs):
        return self.main_program.current_block().append_op(*args, **kwargs)

    def multiple_input(self, input_param_name='input'):
        inputs = self.kwargs.get(input_param_name, [])
        type_error = TypeError(
            "Input of {0} layer should be Variable or sequence of Variable".
            format(self.layer_type))
        if isinstance(inputs, Variable):
            inputs = [inputs]
        elif not isinstance(inputs, list) and not isinstance(inputs, tuple):
            raise type_error
        else:
            for each in inputs:
                if not isinstance(each, Variable):
                    raise type_error
        return inputs

    def input(self, input_param_name='input'):
        inputs = self.multiple_input(input_param_name)
        if len(inputs) != 1:
            raise "{0} layer only takes one input".format(self.layer_type)
        return inputs[0]

    @property
    def param_attr(self):
        default = {'name': None, 'initializer': UniformInitializer()}
        actual = self.kwargs.get('param_attr', None)
        if actual is None:
            actual = default
        for default_field in default.keys():
            if default_field not in actual:
                actual[default_field] = default[default_field]
        return actual

    def bias_attr(self):
        default = {'name': None, 'initializer': ConstantInitializer()}
        bias_attr = self.kwargs.get('bias_attr', None)
        if bias_attr is True:
            bias_attr = default

        if isinstance(bias_attr, dict):
            for default_field in default.keys():
                if default_field not in bias_attr:
                    bias_attr[default_field] = default[default_field]
        return bias_attr

    def multiple_param_attr(self, length):
        param_attr = self.param_attr
        if isinstance(param_attr, dict):
            param_attr = [param_attr]

        if len(param_attr) != 1 and len(param_attr) != length:
            raise ValueError("parameter number mismatch")
        elif len(param_attr) == 1 and length != 1:
            tmp = [None] * length
            for i in xrange(length):
                tmp[i] = copy.deepcopy(param_attr[0])
            param_attr = tmp
        return param_attr

    def iter_inputs_and_params(self, input_param_name='input'):
        inputs = self.multiple_input(input_param_name)
        param_attrs = self.multiple_param_attr(len(inputs))
        for ipt, param_attr in itertools.izip(inputs, param_attrs):
            yield ipt, param_attr

    def input_dtype(self, input_param_name='input'):
        inputs = self.multiple_input(input_param_name)
        dtype = None
        for each in inputs:
            if dtype is None:
                dtype = each.data_type
            elif dtype != each.data_type:
                raise ValueError("Data Type mismatch")
        return dtype

    def create_parameter(self, attr, shape, dtype, suffix='w',
                         initializer=None):
        # Deepcopy the attr so that parameters can be shared in program
        attr_copy = copy.deepcopy(attr)
        if initializer is not None:
            attr_copy['initializer'] = initializer
        if attr_copy['name'] is None:
            attr_copy['name'] = unique_name(".".join([self.name, suffix]))
        self.startup_program.global_block().create_parameter(
            dtype=dtype, shape=shape, **attr_copy)
        return self.main_program.global_block().create_parameter(
            name=attr_copy['name'], dtype=dtype, shape=shape)

    def create_tmp_variable(self, dtype):
        return self.main_program.current_block().create_var(
            name=unique_name(".".join([self.name, 'tmp'])),
            dtype=dtype,
            persistable=False)

    def create_variable(self, *args, **kwargs):
        return self.main_program.current_block().create_var(*args, **kwargs)

    def create_global_variable(self, persistable=False, *args, **kwargs):
        return self.main_program.global_block().create_var(
            *args, persistable=persistable, **kwargs)

    def set_variable_initializer(self, var, initializer):
        assert isinstance(var, Variable)
        self.startup_program.global_block().create_var(
            name=var.name,
            type=var.type,
            dtype=var.data_type,
            shape=var.shape,
            persistable=True,
            initializer=initializer)

    def append_bias_op(self, input_var, num_flatten_dims=None):
        """
        Append bias operator and return its output. If the user does not set 
        bias_attr, append_bias_op will return input_var
         
        :param input_var: the input variable. The len(input_var.shape) is larger
        or equal than 2.
        :param num_flatten_dims: The input tensor will be flatten as a matrix 
        when adding bias.
        `matrix.shape = product(input_var.shape[0:num_flatten_dims]), product(
                input_var.shape[num_flatten_dims:])`
        """
        if num_flatten_dims is None:
            num_flatten_dims = self.kwargs.get('num_flatten_dims', None)
            if num_flatten_dims is None:
                num_flatten_dims = 1

        size = list(input_var.shape[num_flatten_dims:])
        bias_attr = self.bias_attr()
        if not bias_attr:
            return input_var

        b = self.create_parameter(
            attr=bias_attr, shape=size, dtype=input_var.data_type, suffix='b')
        tmp = self.create_tmp_variable(dtype=input_var.data_type)
        self.append_op(
            type='elementwise_add',
            inputs={'X': [input_var],
                    'Y': [b]},
            outputs={'Out': [tmp]})
        return tmp

    def append_activation(self, input_var):
        act = self.kwargs.get('act', None)
        if act is None:
            return input_var
        if isinstance(act, basestring):
            act = {'type': act}
        tmp = self.create_tmp_variable(dtype=input_var.data_type)
        act_type = act.pop('type')
        self.append_op(
            type=act_type,
            inputs={"X": [input_var]},
            outputs={"Y": [tmp]},
            attrs=act)
        return tmp

　　詳細的源碼細節我們下一節會講這里指寫一下實現的方式和調用的函數。

 

　　所以這個卷積過程就完成了。從上文的計算中我們可以看到，同一層的神經元可以共享卷積核，那么對於高位數據的處理將會變得非常簡單。並且使用卷積核后圖片的尺寸變小，方便后續計算，並且我們不需要手動去選取特征，只用設計好卷積核的尺寸，數量和滑動的步長就可以讓它自己去訓練了，省時又省力啊。

 

　　為什么卷積核有效？

　　那么問題來了，雖然我們知道了卷積核是如何計算的，但是為什么使用卷積核計算后分類效果要由於普通的神經網絡呢？我們仔細來看一下上面計算的結果。通過第一個卷積核計算后的feature_map是一個三維數據，在第三列的絕對值最大，說明原始圖片上對應的地方有一條垂直方向的特征，即像素數值變化較大；而通過第二個卷積核計算后，第三列的數值為0，第二行的數值絕對值最大，說明原始圖片上對應的地方有一條水平方向的特征。

　　仔細思考一下，這個時候，我們設計的兩個卷積核分別能夠提取，或者說檢測出原始圖片的特定的特征。此時我們其實就可以把卷積核就理解為特征提取器啊！現在就明白了，為什么我們只需要把圖片數據灌進去，設計好卷積核的尺寸、數量和滑動的步長就可以讓自動提取出圖片的某些特征，從而達到分類的效果啊！

　　注：1.此處的卷積運算是兩個卷積核大小的矩陣的內積運算，不是矩陣乘法。即相同位置的數字相乘再相加求和。不要弄混淆了。

　　　　2.卷積核的公式有很多，這只是最簡單的一種。我們所說的卷積核在數字信號處理里也叫濾波器，那濾波器的種類就多了，均值濾波器，高斯濾波器，拉普拉斯濾波器等等，不過，不管是什么濾波器，都只是一種數學運算，無非就是計算更復雜一點。

            3.每一層的卷積核大小和個數可以自己定義，不過一般情況下，根據實驗得到的經驗來看，會在越靠近輸入層的卷積層設定少量的卷積核，越往后，卷積層設定的卷積核數目就越多。具體原因大家可以先思考一下，小結里會解釋原因。

 

• 池化層（Pooling Layer）

　　通過上一層2*2的卷積核操作后，我們將原始圖像由4*4的尺寸變為了3*3的一個新的圖片。池化層的主要目的是通過降采樣的方式，在不影響圖像質量的情況下，壓縮圖片，減少參數。簡單來說，假設現在設定池化層采用MaxPooling，大小為2*2，步長為1，取每個窗口最大的數值重新，那么圖片的尺寸就會由3*3變為2*2：(3-2)+1=2。從上例來看，會有如下變換：

 　　　　　　圖3 Max Pooling結果

     通常來說，池化方法一般有一下兩種：

• MaxPooling：取滑動窗口里最大的值
• AveragePooling：取滑動窗口內所有值的平均值

 

　 為什么采用Max Pooling？

　　從計算方式來看，算是最簡單的一種了，取max即可，但是這也引發一個思考，為什么需要Max Pooling，意義在哪里？如果我們只取最大值，那其他的值被舍棄難道就沒有影響嗎？不會損失這部分信息嗎？如果認為這些信息是可損失的，那么是否意味着我們在進行卷積操作后仍然產生了一些不必要的冗余信息呢？

　　其實從上文分析卷積核為什么有效的原因來看，每一個卷積核可以看做一個特征提取器，不同的卷積核負責提取不同的特征，我們例子中設計的第一個卷積核能夠提取出“垂直”方向的特征，第二個卷積核能夠提取出“水平”方向的特征，那么我們對其進行Max Pooling操作后，提取出的是真正能夠識別特征的數值，其余被舍棄的數值，對於我提取特定的特征並沒有特別大的幫助。那么在進行后續計算使，減小了feature map的尺寸，從而減少參數，達到減小計算量，缺不損失效果的情況。

　　不過並不是所有情況Max Pooling的效果都很好，有時候有些周邊信息也會對某個特定特征的識別產生一定效果，那么這個時候舍棄這部分“不重要”的信息，就不划算了。所以具體情況得具體分析，如果加了Max Pooling后效果反而變差了，不如把卷積后不加Max Pooling的結果與卷積后加了Max Pooling的結果輸出對比一下，看看Max Pooling是否對卷積核提取特征起了反效果。

 

     Zero Padding

      所以到現在為止，我們的圖片由4*4，通過卷積層變為3*3，再通過池化層變化2*2，如果我們再添加層，那么圖片豈不是會越變越小？這個時候我們就會引出“Zero Padding”（補零），它可以幫助我們保證每次經過卷積或池化輸出后圖片的大小不變，如，上述例子我們如果加入Zero Padding，再采用3*3的卷積核，那么變換后的圖片尺寸與原圖片尺寸相同，如下圖所示：

　　圖4 zero padding結果

 　　通常情況下，我們希望圖片做完卷積操作后保持圖片大小不變，所以我們一般會選擇尺寸為3*3的卷積核和1的zero padding，或者5*5的卷積核與2的zero padding，這樣通過計算后，可以保留圖片的原始尺寸。那么加入zero padding后的feature_map尺寸 =( width + 2 * padding_size - filter_size )/stride + 1

　　注：這里的width也可換成height，此處是默認正方形的卷積核，weight = height，如果兩者不相等，可以分開計算，分別補零。

 

• Flatten層 & Fully Connected Layer

　　到這一步，其實我們的一個完整的“卷積部分”就算完成了，如果想要疊加層數，一般也是疊加“Conv-MaxPooing",通過不斷的設計卷積核的尺寸，數量，提取更多的特征，最后識別不同類別的物體。做完Max Pooling后，我們就會把這些數據“拍平”，丟到Flatten層，然后把Flatten層的output放到full connected Layer里，采用softmax對其進行分類。

　　　　圖5 Flatten過程

　　

• 小結

　　這一節我們介紹了最基本的卷積神經網絡的基本層的定義，計算方式和起的作用。有幾個小問題可以供大家思考一下：　

1.卷積核的尺寸必須為正方形嗎？可以為長方形嗎？如果是長方形應該怎么計算？

2.卷積核的個數如何確定？每一層的卷積核的個數都是相同的嗎？ 

3.步長的向右和向下移動的幅度必須是一樣的嗎？

 

　　如果對上面的講解真的弄懂了的話，其實這幾個問題並不難回答。下面給出我的想法，可以作為參考：

　　1.卷積核的尺寸不一定非得為正方形。長方形也可以，只不過通常情況下為正方形。如果要設置為長方形，那么首先得保證這層的輸出形狀是整數，不能是小數。如果你的圖像是邊長為 28 的正方形。那么卷積層的輸出就滿足 [ (28 - kernel_size)/ stride ] + 1 ，這個數值得是整數才行，否則沒有物理意義。譬如，你算得一個邊長為 3.6 的 feature map 是沒有物理意義的。 pooling 層同理。FC 層的輸出形狀總是滿足整數，其唯一的要求就是整個訓練過程中 FC 層的輸入得是定長的。如果你的圖像不是正方形。那么在制作數據時，可以縮放到統一大小（非正方形），再使用非正方形的 kernel_size 來使得卷積層的輸出依然是整數。總之，撇開網絡結果設定的好壞不談，其本質上就是在做算術應用題：如何使得各層的輸出是整數。

　　2.由經驗確定。通常情況下，靠近輸入的卷積層，譬如第一層卷積層，會找出一些共性的特征，如手寫數字識別中第一層我們設定卷積核個數為5個，一般是找出諸如"橫線"、“豎線”、“斜線”等共性特征，我們稱之為basic feature，經過max pooling后，在第二層卷積層，設定卷積核個數為20個，可以找出一些相對復雜的特征，如“橫折”、“左半圓”、“右半圓”等特征，越往后，卷積核設定的數目越多，越能體現label的特征就越細致，就越容易分類出來，打個比方，如果你想分類出“0”的數字，你看到這個特征，能推測是什么數字呢？只有越往后，檢測識別的特征越多，試過能識別這幾個特征，那么我就能夠確定這個數字是“0”。

　　3.有stride_w和stride_h，后者表示的就是上下步長。如果用stride，則表示stride_h=stride_w=stride。

 

 

---

　　手寫數字識別的CNN網絡結構

　　上面我們了解了卷積神經網絡的基本結構后，現在來具體看一下在實際數據---手寫數字識別中是如何操作的。上文中我定義了一個最基本的CNN網絡。如下(代碼詳見github)

def convolutional_neural_network_org(img):
    # first conv layer
    conv_pool_1 = paddle.networks.simple_img_conv_pool(
        input=img,
        filter_size=3,
        num_filters=20,
        num_channel=1,
        pool_size=2,
        pool_stride=2,
        act=paddle.activation.Relu())
    # second conv layer
    conv_pool_2 = paddle.networks.simple_img_conv_pool(
        input=conv_pool_1,
        filter_size=5,
        num_filters=50,
        num_channel=20,
        pool_size=2,
        pool_stride=2,
        act=paddle.activation.Relu())
    # fully-connected layer
    predict = paddle.layer.fc(
        input=conv_pool_2, size=10, act=paddle.activation.Softmax())
    return predict

 

　　那么它的網絡結構是：

　　conv1----> conv2---->fully Connected layer

　　非常簡單的網絡結構。第一層我們采取的是3*3的正方形卷積核，個數為20個，深度為1，stride為2，pooling尺寸為2*2，激活函數采取的為RELU；第二層只對卷積核的尺寸、個數和深度做了些變化，分別為5*5，50個和20；最后鏈接一層全連接，設定10個label作為輸出，采用Softmax函數作為分類器，輸出每個label的概率。

　　那么這個時候我考慮的問題是，既然上面我們已經了解了卷積核，改變卷積核的大小是否會對我的結果造成影響？增多卷積核的數目能夠提高准確率？於是我做了個實驗：

• 　第一次改進：僅改變第一層與第二層的卷積核數目的大小，其他保持不變。可以看到結果提升了0.06%
• 　第二次改進：保持3*3的卷積核大小，僅改變第二層的卷積核數目，其他保持不變，可以看到結果相較於原始參數提升了0.08%

　　由以上結果可以看出，改變卷積核的大小與卷積核的數目會對結果產生一定影響，在目前手寫數字識別的項目中，縮小卷積核尺寸，增加卷積核數目都會提高准確率。不過以上實驗只是一個小測試，有興趣的同學可以多做幾次實驗，看看參數帶來的具體影響，下篇文章我們會着重分析參數的影響。

　　這篇文章主要介紹了神經網絡的預備知識，卷積神經網絡的常見的層及基本的計算過程，看完后希望大家明白以下幾個知識點：

• 為什么卷積神經網絡更適合於圖像分類？相比於傳統的神經網絡優勢在哪里？
• 卷積層中的卷積過程是如何計算的？為什么卷積核是有效的？
• 卷積核的個數如何確定？應該選擇多大的卷積核對於模型來說才是有效的？尺寸必須為正方形嗎？如果是長方形因該怎么做？
• 步長的大小會對模型的效果產生什么樣的影響？垂直方向和水平方向的步長是否得設定為相同的？
• 為什么要采用池化層，Max Pooling有什么好處？
• Zero Padding有什么作用？如果已知一個feature map的尺寸，如何確定zero padding的數目？

　　

    上面的問題，有些在文章中已經詳細講過，有些大家可以根據文章的內容多思考一下。最后給大家留幾個問題思考一下：

• 為什么改變卷積核的大小能夠提高結果的准確率？卷積核大小對於分類結果是如何影響的？
• 卷積核的參數是怎么求的？一開始隨機定義一個，那么后來是如何訓練才能使這個卷積核識別某些特定的特征呢？
• 1*1的卷積核有意義嗎？為什么有些網絡層結構里會采用1*1的卷積核？

　　

　　下篇文章我們會着重講解以下幾點：

• 卷積核的參數如何確定？隨機初始化一個數值后，是如何訓練得到一個能夠識別某些特征的卷積核的？
• CNN是如何進行反向傳播的？
• 如何調整CNN里的參數？
• 如何設計最適合的CNN網絡結構？
• 能夠不用調用框架的api，手寫一個CNN，並和paddlepaddle里的實現過程做對比，看看有哪些可以改進的？

 

 

ps：本篇文章是基於個人對CNN的理解來寫的，本人能力有限，有些地方可能寫的不是很嚴謹，如有錯誤或疏漏之處，請留言給我，我一定會仔細核實並修改的^_^！不接受無腦噴哦~此外，文中的圖表結構均為自己所做，希望不要被人隨意抄襲，可以進行非商業性質的轉載，需要轉載留言或發郵件即可，希望能夠尊重勞動成果，謝謝！有不懂的也請留言給我，我會盡力解答的哈~