深度學習基礎（CNN詳解以及訓練過程1）

本文轉載自查看原文 2018-07-11 18:11 14921 機器學習

深度學習是一個框架，包含多個重要算法:

Convolutional Neural Networks(CNN)卷積神經網絡
AutoEncoder自動編碼器
Sparse Coding稀疏編碼
Restricted Boltzmann Machine(RBM)限制波爾茲曼機
Deep Belief Networks(DBN)深信度網絡
Recurrent neural Network(RNN)多層反饋循環神經網絡神經網絡

對於不同問題(圖像，語音，文本)，需要選用不同網絡模型比如CNN RESNET等才能達到更好效果。

今天來講最基礎的CNN網絡。

可以不可以模仿人類大腦的這個特點，構造多層的神經網絡，較低層的識別初級的圖像特征，若干底層特征組成更上一層特征，最終通過多個層級的組合，最終在頂層做出分類呢？答案是肯定的，這也是許多深度學習算法（包括CNN）的靈感來源。

CNN網絡介紹

卷積神經網絡是一種多層神經網絡，擅長處理圖像特別是大圖像的相關機器學習問題。

卷積網絡通過一系列方法，成功將數據量龐大的圖像識別問題不斷降維，最終使其能夠被訓練。CNN最早由Yann LeCun提出並應用在手寫字體識別上（MINST）。LeCun提出的網絡稱為LeNet，其網絡結構如下：

這是一個最典型的卷積網絡，由卷積層、池化層、全連接層組成。其中卷積層與池化層配合，組成多個卷積組，逐層提取特征，最終通過若干個全連接層完成分類。

卷積層完成的操作，可以認為是受局部感受野概念的啟發，而池化層，主要是為了降低數據維度。

綜合起來說，CNN通過卷積來模擬特征區分，並且通過卷積的權值共享及池化，來降低網絡參數的數量級，最后通過傳統神經網絡完成分類等任務。

降低參數量級

為什么要降低參數量級？從下面的例子就可以很容易理解了。

如果我們使用傳統神經網絡方式，對一張圖片進行分類，那么，我們把圖片的每個像素都連接到隱藏層節點上，那么對於一張1000x1000像素的圖片，如果我們有1M隱藏層單元，那么一共有10^12個參數，這顯然是不能接受的。（如下圖所示）

但是我們在CNN里，可以大大減少參數個數，我們基於以下兩個假設：

1）最底層特征都是局部性的，也就是說，我們用10x10這樣大小的過濾器就能表示邊緣等底層特征

2）圖像上不同小片段，以及不同圖像上的小片段的特征是類似的，也就是說，我們能用同樣的一組分類器來描述各種各樣不同的圖像

基於以上兩個，假設，我們就能把第一層網絡結構簡化如下：

我們用100個10x10的小過濾器，就能夠描述整幅圖片上的底層特征。

卷積（Convolution）

卷積運算的定義如下圖所示：

如圖所示，我們有一個5x5的圖像，我們用一個3x3的卷積核：

1　　0　　1

0　　1　　0

1　　0　　1

來對圖像進行卷積操作（可以理解為有一個滑動窗口，把卷積核與對應的圖像像素做乘積然后求和），得到了3x3的卷積結果。

這個過程我們可以理解為我們使用一個過濾器（卷積核）來過濾圖像的各個小區域，從而得到這些小區域的特征值。

在實際訓練過程中，卷積核的值是在學習過程中學到的。

在具體應用中，往往有多個卷積核，可以認為，每個卷積核代表了一種圖像模式，如果某個圖像塊與此卷積核卷積出的值大，則認為此圖像塊十分接近於此卷積核。如果我們設計了6個卷積核，可以理解：我們認為這個圖像上有6種底層紋理模式，也就是我們用6中基礎模式就能描繪出一副圖像。以下就是24種不同的卷積核的示例：

池化（Pooling）

池化聽起來很高深，其實簡單的說就是下采樣。池化的過程如下圖所示：

上圖中，我們可以看到，原始圖片是20x20的，我們對其進行下采樣，采樣窗口為10x10，最終將其下采樣成為一個2x2大小的特征圖。

之所以這么做的原因，是因為即使做完了卷積，圖像仍然很大（因為卷積核比較小），所以為了降低數據維度，就進行下采樣。

之所以能這么做，是因為即使減少了許多數據，特征的統計屬性仍能夠描述圖像，而且由於降低了數據維度，有效地避免了過擬合。

在實際應用中，池化根據下采樣的方法，分為最大值下采樣（Max-Pooling）與平均值下采樣（Mean-Pooling）。

全連接層（fully connected layers，FC）

在整個卷積神經網絡中起到“分類器”的作用。如果說卷積層、池化層和激活函數層等操作是將原始數據映射到隱層特征空間的話，全連接層則起到將學到的“分布式特征表示”映射到樣本標記空間的作用。在實際使用中，全連接層可由卷積操作實現：對前層是全連接的全連接層可以轉化為卷積核為1x1的卷積；而前層是卷積層的全連接層可以轉化為卷積核為hxw的全局卷積，h和w分別為前層卷積結果的高和寬。

全連接層的實現

LeNet介紹

下面再回到LeNet網絡結構：

這回我們就比較好理解了，原始圖像進來以后，先進入一個卷積層C1，由6個5x5的卷積核組成，卷積出28x28的圖像，然后下采樣到14x14（S2）。

接下來，再進一個卷積層C3，由16個5x5的卷積核組成，之后再下采樣到5x5（S4）。

注意，這里S2與C3的連接方式並不是全連接，而是部分連接，如下圖所示：

其中行代表S2層的某個節點，列代表C3層的某個節點。

我們可以看出，C3-0跟S2-0,1,2連接，C3-1跟S2-1,2,3連接，后面依次類推，仔細觀察可以發現，其實就是排列組合：

0 0 0 1 1 1

0 0 1 1 1 0

0 1 1 1 0 0

...

1 1 1 1 1 1

我們可以領悟作者的意圖，即用不同特征的底層組合，可以得到進一步的高級特征，例如：/ + \ = ^ （比較抽象O(∩_∩)O~），再比如好多個斜線段連成一個圓等等。

最后，通過全連接層C5、F6得到10個輸出，對應10個數字的概率。

最后說一點個人的想法哈，我認為第一個卷積層選6個卷積核是有原因的，大概也許可能是因為0~9其實能用以下6個邊緣來代表：

是不是有點道理呢，哈哈

然后C3層的數量選擇上面也說了，是從選3個開始的排列組合，所以也是可以理解的。

其實這些都是針對特定問題的trick，現在更加通用的網絡的結構都會復雜得多，至於這些網絡的參數如何選擇，那就需要我們好好學習了。

-----------------------------------------------------------------------------------------------------------------------

訓練過程

卷積網絡在本質上是一種輸入到輸出的映射，它能夠學習大量的輸入與輸出之間的映射關系，而不需要任何輸入和輸出之間的精確的數學表達式，只要用已知的模式對卷積網絡加以訓練，網絡就具有輸入輸出對之間的映射能力。卷積網絡執行的是有監督訓練，所以其樣本集是由形如：（輸入向量，理想輸出向量）的向量對構成的。所有這些向量對，都應該是來源於網絡即將模擬的系統的實際“運行”結果。它們可以是從實際運行系統中采集來的。在開始訓練前，所有的權都應該用一些不同的小隨機數進行初始化。“小隨機數”用來保證網絡不會因權值過大而進入飽和狀態，從而導致訓練失敗；“不同”用來保證網絡可以正常地學習。實際上，如果用相同的數去初始化權矩陣，則網絡無能力學習。

卷積神經網絡的訓練過程與傳統神經網絡類似，也是參照了反向傳播算法。

第一階段，向前傳播階段：

a）從樣本集中取一個樣本(X,Y_p)，將X輸入網絡；

b）計算相應的實際輸出O_p。

在此階段，信息從輸入層經過逐級的變換，傳送到輸出層。這個過程也是網絡在完成訓練后正常運行時執行的過程。在此過程中，網絡執行的是計算（實際上就是輸入與每層的權值矩陣相點乘，得到最后的輸出結果）：

O_p=F_n（…（F₂（F₁（X_pW^（1））W^（2））…）W^（n））

第二階段，向后傳播階段

a）算實際輸出O_p與相應的理想輸出Y_p的差；

b）按極小化誤差的方法反向傳播調整權矩陣。

以上內容摘自其他博客，由於我也沒有仔細了解這一塊，建議直接參考原博客。

手寫數字分類的例子，基於tensorflow

引自：使用TensorFlow編寫識別數字的CNN訓練程序詳解

CNN的結構

從網上借用一張圖片來表示一下，是一個有2層hidden layer的CNN。

程序中設置的一些參數是：
卷積層1：kernel_size [5, 5], stride=1， 4個卷積窗口
卷積層2：kernel_size [5, 5], stride=1， 6個卷積窗口
池化層： pool_size [2, 2], stride = 2
全連接層1: 1024個特征

MNIST數據的獲取

以往我們獲取MINIST的方式是:

from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

現在可以：

from tensorflow.contrib import learn
mnist = learn.datasets.load_dataset('mnist')

通過mnist.train, mnist.test, mnist.validation來獲得3個數據集，每個數據集里面的方法有(已train為例)：

train.images 圖片數據，二維數組 (55000, 784) dtype=float32
train.labels 圖片的分類，一維數組，每個數值表示圖片對應的數字
array([7, 3, 4, …, 5, 6, 8], dtype=uint8)
train.num_examples 圖片數量 55000
train.next_batch 下一批數據
n = train.next_batch n[0] 是images n[1]是labels

第一次load MNIST數據的時候，會自動從網上下載，放到當前目錄的MNIST-data目錄下

第一種加載方式，有一個one-hot參數，此時每個樣本的label，返回的是一個長度10的vector，其中只有一個位置是1，其他都是0。第二種方式，沒有這個參數，如果需要的話，得直接調用datasets.mnist.read_data_sets

定義卷積層

在tf.contrib.layers里面有convolution2d，conv2d等方法，其實都是convolution方法的別名

convolution(inputs, num_outputs, kernel_size, stride=1, padding='SAME', data_format=None, rate=1, activation_fn=nn.relu, normalizer_fn=None, normalizer_params=None, weights_initializer=initializers.xavier_initializer(), weights_regularizer=None, biases_initializer=init_ops.zeros_initializer, biases_regularizer=None, reuse=None, variables_collections=None, outputs_collections=None, trainable=True, scope=None)

這個函數很強大，1到3維的卷積都支持。(我暫時只用過2維)

inputs: 輸入變量，是一個N+2維的Tensor
- 類型要求是一個Tensor，而我們一般訓練的數據都是常量(比如mnist，load以后得到是python的數據類型，不是tf的)，所以需要把用tf的方法做一下轉換，比如tf.reshape
- 為什么是N+2維呢，比如圖像，除了寬度和高度，實際上還有樣本數量和通道數量(如RGB3通道)，所以多了2維。
- inputs的格式，由date_format這個參數來覺得，比如2維，有NHWC和NCHW兩種。N是樣本數量，H高度，W寬度，C通道數。
num_outputs: 卷積filter的數量，或者說提取的特征數量，比如5,10
kernel_size: 卷積核的大小，是N個參數的list，比如二維圖像，可以時候[10,10]，如果參數值相同，用一個整數來表示也可以；
stride: 卷積步長，同樣是N個參數的序列，或者都相等的話，用一個整數來表示，默認是1.
padding: 字符串格式，默認SAME，可選’VALID’。（想問：這兩個效果上有多大差異？）
data_format: 字符串，指定inputs的格式
- 一維數據：”NWC” (default) and “NCW”
- 二維數據：”NHWC” (default) and “NCHW”
- 三維數據：”NDHWC”
- 也就是，不指定的話，通道數都是最后一個參數。
rate: a sequence of N positive integers specifying the dilation rate to use for a’trous convolution. Can be a single integer to specify the same value for all spatial dimensions. (暫時沒看到其作用)
activation_fn: 激活函數，默認relu
normalizer_fn: normalization function to use instead of biases.（沒用過，不知道起作用）
normalizer_params： normalization function parameters.
weights_initializer：這不用說了，有默認值，估計用默認的就可以了。
weights_regularizer: Optional regularizer for the weights.(沒明白為什么需要這個)
biases_initializer: 有默認值，一般也就不用指定。
biases_regularizer: …
reuse: whether or not the layer and its variables should be reused. To be able to reuse the layer scope must be given. 應該都需要reuse吧，所以這個參數默認為True更好，現在是None。
variables_collections：怎么用暫時不太明白，但應該不用指定也可以；
outputs_collections：同上；
trainable： If True also add variables to the graph collection GraphKeys.TRAINABLE_VARIABLES，默認是True。（這個是不是說在fit的時候需要設為True，evaluate和predict的時候為false？）
scope：也即是variable_scope，如果用多個卷積層的話，需要設置這個參數，以便把每一次的weight和bias區別出來。

我們在對MNIST做卷積的時候，只要指定inputs, num_outputs, kernel_size, scope這幾個參數就可以了，比如:

conv1 = tf.contrib.layers.conv2d(inputs, 4, [5, 5], 'conv_layer1')
#stride默認1，weights和biases也都是默認的

定義池化層

可以用 tf.contrib.layers.max_pool2d或者tf.contrib.layers.avg_pool2d

max_pool2d(inputs, kernel_size, stride=2, padding=’VALID’, data_format=DATA_FORMAT_NHWC, outputs_collections=None, scope=None)

inputs: 就是卷積的輸出了；
kernel_size: 是不是叫pool_size更貼切。[kernel_height, kernel_width]或者是一個整數；
stride： [stride_height, stride_width]，不過文檔上說目前這兩個值必須一樣
padding：這里默認是VALID，和卷積默認不一樣，為什么要這樣呢？
data_format: 注意和卷積用的一樣哦；
outputs_collections: …
scope: pooling的時候沒有參數，需要scope嗎？

pool1 = tf.contrib.layers.max_pool2d(conv1, [2, 2], padding='SAME')

定義全連接層

tf.contrib.layers下有可用的全連接方法：

fully_connected(inputs, num_outputs, activation_fn=nn.relu, normalizer_fn=None, normalizer_params=None, weights_initializer=initializers.xavier_initializer(), weights_regularizer=None, biases_initializer=init_ops.zeros_initializer, biases_regularizer=None, reuse=None, variables_collections=None, outputs_collections=None, trainable=True, scope=None)

看這個函數，參數和卷積很多地方是一樣的, 我們可以這樣用：

fc = tf.contrib.layers.fully_connected(inputs, 1024, scope='fc_layer')

唯一需要注意的是這里的inputs參數，一般是二維的形式[batch_size, depth]，而前面卷積的結果，一般是[batch_size, height, width, channels]的形式，所以需要做一個flatten操作后再傳給fully_connected。

一般在fc之后還會做dropout，可以用如下方法：

dropout(inputs, keep_prob=0.5, noise_shape=None, is_training=True, outputs_collections=None, scope=None)

參數的意義很明顯，其中is_training需要注意一下，在訓練的時候傳True，其他情況下傳False。

dropout是指在深度學習網絡的訓練過程中，對於神經網絡單元，按照一定的概率將其暫時從網絡中丟棄。注意是暫時，對於隨機梯度下降來說，由於是隨機丟棄，故而每一個mini-batch都在訓練不同的網絡。

dropout是CNN中防止過擬合提高效果的一個大殺器。

定義logits

全連接之后，一般就是用softmax做分類，然后定義loss，就可以訓練了。但是看官方的例子，softmax前還加了一步，計算叫logits的東西，代碼里面的說明是：

We don’t apply softmax here because 
tf.nn.softmax_cross_entropy_with_logits accepts the unscaled logits 
and performs the softmax internally for efficiency.

為什么要這樣暫時不太明白，但是依樣畫葫蘆，定義logtis本身很簡單，做一個線性變換，把FC的結果映射到分類的數量上：

def inference(x, num_class):
  with tf.variable_scope('softmax'):
    dtype = x.dtype.base_dtype
    # Set up the requested initialization.
    init_mean = 0.0
    init_stddev = 0.0
    weights = tf.get_variable('weights',
                                [x.get_shape()[1], num_class], initializer=init_ops.random_normal_initializer(init_mean, init_stddev, dtype=dtype), dtype=dtype)
    biases = tf.get_variable('bias', [num_class], initializer=init_ops.random_normal_initializer(init_mean, init_stddev, dtype=dtype), dtype=dtype)

    logits = tf.nn.xw_plus_b(x, weights, biases)
    return logits

定義loss

在tf.contrib.losses下有一些預定義的loss函數，比如直接用

softmax_cross_entropy(logits, onehot_labels, weights=_WEIGHT_SENTINEL, label_smoothing=0, scope=None)

注意這里的label是onehot格式的, 我們從mnist獲取的label要轉換成這個格式。

定義train_op

可以用tf.contrib.layers.optimize_loss，通過傳遞不同的參數，就可以調用不同的優化方法。

optimize_loss(loss,
              global_step,
              learning_rate,
              optimizer,
              gradient_noise_scale=None,
              gradient_multipliers=None,
              clip_gradients=None,
              learning_rate_decay_fn=None,
              update_ops=None,
              variables=None,
              name=None,
              summaries=None,
              colocate_gradients_with_ops=False):

預定義的optimizer有：

OPTIMIZER_CLS_NAMES = {
    "Adagrad": train.AdagradOptimizer,
    "Adam": train.AdamOptimizer,
    "Ftrl": train.FtrlOptimizer,
    "Momentum": train.MomentumOptimizer,
    "RMSProp": train.RMSPropOptimizer,
    "SGD": train.GradientDescentOptimizer,
}
或者這么寫
train_op = tf.contrib.layers.optimize_loss(
            loss, tf.contrib.framework.get_global_step(), optimizer='Adagrad', learning_rate=0.1)

model和Estimator

結合上面的內容，就可以定義出model，從而用Estimator完成訓練，預測等功能，完整的程序如下：

import numpy as np

import sklearn.metrics as metrics
import tensorflow as tf
from PIL import Image
from tensorflow.contrib import learn
from tensorflow.contrib.learn import SKCompat
from tensorflow.contrib.learn.python.learn.estimators import model_fn as model_fn_lib
from tensorflow.python.ops import init_ops

IMAGE_SIZE = 28
LOG_DIR = './ops_logs'

mnist = learn.datasets.load_dataset('mnist')

def inference(x, num_class):
  with tf.variable_scope('softmax'):
    dtype = x.dtype.base_dtype
    init_mean = 0.0
    init_stddev = 0.0
    weight = tf.get_variable('weights',
                                [x.get_shape()[1], num_class], initializer=init_ops.random_normal_initializer(init_mean, init_stddev, dtype=dtype), dtype=dtype)
    biases = tf.get_variable('bias', [num_class], initializer=init_ops.random_normal_initializer(init_mean, init_stddev, dtype=dtype), dtype=dtype)

    logits = tf.nn.xw_plus_b(x, weight, biases)
    return logits

def model(features, labels, mode):
    if mode != model_fn_lib.ModeKeys.INFER:
        labels = tf.one_hot(labels, 10, 1, 0)
    else:
        labels = None

    inputs = tf.reshape(features, (-1, IMAGE_SIZE, IMAGE_SIZE, 1))

    #conv1
    conv1 = tf.contrib.layers.conv2d(inputs, 4, [5, 5], scope='conv_layer1', activation_fn=tf.nn.tanh);
    pool1 = tf.contrib.layers.max_pool2d(conv1, [2, 2], padding='SAME')
    #conv2
    conv2 = tf.contrib.layers.conv2d(pool1, 6, [5, 5], scope='conv_layer2', activation_fn=tf.nn.tanh);
    pool2 = tf.contrib.layers.max_pool2d(conv2, [2, 2], padding='SAME')
    pool2_shape = pool2.get_shape()
    pool2_in_flat = tf.reshape(pool2, [pool2_shape[0].value or -1, np.prod(pool2_shape[1:]).value])
    #fc
    fc1 = tf.contrib.layers.fully_connected(pool2_in_flat, 1024, scope='fc_layer1', activation_fn=tf.nn.tanh)
    #dropout
    is_training = False
    if mode == model_fn_lib.ModeKeys.TRAIN:
        is_training = True

    dropout = tf.contrib.layers.dropout(fc1, keep_prob=0.5, is_training=is_training, scope='dropout')

    logits = inference(dropout, 10)
    prediction = tf.nn.softmax(logits)
    if mode != model_fn_lib.ModeKeys.INFER:
        loss = tf.contrib.losses.softmax_cross_entropy(logits, labels)
        train_op = tf.contrib.layers.optimize_loss(
            loss, tf.contrib.framework.get_global_step(), optimizer='Adagrad',
            learning_rate=0.1)
    else:
        train_op = None
        loss = None

    return {'class': tf.argmax(prediction, 1), 'prob': prediction}, loss, train_op


classifier = SKCompat(learn.Estimator(model_fn=model, model_dir=LOG_DIR))

classifier.fit(mnist.train.images, mnist.train.labels, steps=1000, batch_size=300)

predictions = classifier.predict(mnist.test.images)
score = metrics.accuracy_score(mnist.test.labels, predictions['class'])
print('Accuracy: {0:f}'.format(score))

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 CNN基礎四：監測並控制訓練過程的法寶——Keras回調函數和TensorBoard Tensorflow2.0學習（5）---神經網絡訓練過程（原）torch的訓練過程 yolov3訓練過程參數解析可視化pytorch訓練過程實現能夠在訓練過程中手動更改學習率 Tensorflow學習筆記6：解決tensorflow訓練過程中GPU未調用問題深度學習之卷積神經網絡(CNN)詳解與代碼實現（一）【強化學習玩轉超級馬里奧】05-最最簡單的超級馬里奧訓練過程 T6-Tensorboard 可視化之訓練過程