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


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

  • 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,Yp),將X輸入網絡;

b)計算相應的實際輸出Op

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

          Op=Fn(…(F2(F1(XpW(1))W(2))…)W(n)

第二階段,向后傳播階段

a)算實際輸出Op與相應的理想輸出Yp的差;

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目錄下

  1. 第一種加載方式,有一個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刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM