深度學習是一個框架,包含多個重要算法:
- 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目錄下
- 第一種加載方式,有一個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))