深入淺出解讀卷積神經網絡
作者：石文華
卷積神經網絡和全連接的神經網絡結構上的差異還是比較大的，全連接的網絡，相鄰兩層的節點都有邊相連，而卷積神經網絡，相鄰節點只有部分節點相連。
卷積神經網絡
經網絡結構圖
圖2 卷積神經網絡結構圖
卷積神經網絡和全連接的神經網絡結構上的差異還是比較大的，全連接的網絡，相鄰兩層的節點都有邊相連，而卷積神經網絡，相鄰節點只有部分節點相連。
全連接神經網絡處理圖像的***問題在于全連接層的參數太多，參數太多的話容易發生過擬合而且會導致計算速度減慢，卷積神經網絡可以減小參數個數的目的。
假設輸入是一張圖片大小為28*28*3，***層隱藏層有500個節點，那么***層的參數就有28*28*3*500+500=1176000個參數，當圖片更大時，參數就更多了，而且這只是***層。
那么為什么卷積神經網絡可以達到減小參數的目的呢？
卷積神經網絡最為關鍵的有卷積層，池化層，全連接層。
卷積層
卷積層中每個節點的輸入只是上一層神經網絡的一小塊，通常由卷積核來實現，卷積核是一個過濾器，可以想象成一個掃描窗口，扣到每張圖片上，然后根據設置好的大小步長等等掃描圖片，計算規則是被扣的圖像像素矩陣跟卷積核的權重對應位置相乘然后求和，每掃描一次得到一個輸出。卷積層所做的工作可以理解為對圖像像素的每一小塊進行特征抽象。可以通過多個不同的卷積核對同一張圖片進行卷積，卷積核的個數，其實就是卷積之后輸出矩陣的深度。卷積神經網絡的參數個數與圖片大小無關，只跟過濾器的尺寸、深度以及卷積核的個數（輸出矩陣的深度）有關。假設是還是28*28*3的圖片，卷積核的大小設為3*3*3，輸出矩陣的深度為500，那么參數個數為3*3*3*500+500=14000個參數，對比全連接層，參數減少了很多。
圖3 形象的卷積層示例
池化層
池化層可以認為是將一張高分辨率的圖片轉化為低分辨率的圖片。可以非常有效的縮小矩陣的尺寸，從而減小全連接層的參數個數，這樣可以加快計算速率同時又防止過擬合，池化，可以減小模型，提高速度，同時提高所提取特征的魯棒性。
使用2*2的過濾器步長為2，***池化如下圖所示：
圖4 2*2過濾器***池化示例圖
我們可以將卷積層和池化層看成是自動特征提取就可以了。
通過上面直觀的介紹，現在我們就知道為什么卷積神經網絡可以達到減小參數的目的了？
和全連接神經網絡相比，卷積神經網絡的優勢在于共享權重和稀疏連接。共享權重在于參數只與過濾器有關。卷積神經網絡減少參數的另外一個原因是稀疏連接。輸出節點至于輸入圖片矩陣的部分像素矩陣有關，也就是跟卷積核扣上去的那一小塊矩陣有關。這就是稀疏連接的概念。
卷積神經網絡通過權重共享和稀疏連接來減少參數的。從而防止過度擬合。
訓練過程
卷積神經網絡的訓練過程大致可分為如下幾步：
***步：導入相關庫、加載參數
- import math
- import numpy as np
- import tensorflow as tf
- import matplotlib.pyplot as plt
- import h5py
- from tensorflow.python.framework import ops
- from tf_utils import *
- np.random.seed(1)
- X_train_orig,Y_train_orig,X_test_orig,Y_test_orig,classes=load_dataset()
- index=0
- plt.imshow(X_train_orig[index])
- print("y="+str(np.squeeze(Y_train_orig[:,index])))
- plt.show()
第二步：歸一化，有利于加快梯度下降
- X_train=X_train_orig/255.0
- X_test=X_test_orig/255.0
- Y_train=convert_to_one_hot(Y_train_orig,6)
- Y_test=convert_to_one_hot(Y_test_orig,6)
第三步：定義參數及卷積神經網絡結構
- def create_placeholder(num_px,channel,n_y):
- X=tf.placeholder(tf.float32,shape=(None,num_px,num_px,channel),name='X')
- Y=tf.placeholder(tf.float32,shape=(None,n_y),name='Y')
- return X,Y
- X,Y=create_placeholder(64,3,6)
- print("X="+str(X))
- print("Y="+str(Y))
- def weight_variable(shape):
- return tf.Variable(tf.truncated_normal(shape,stddev=0.1))
- def bias_variable(shape):
- return tf.Variable(tf.constant(0.1,shape=shape))
- def conv2d(x,W):
- return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')
- def max_pool_2x2(x):
- return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
- def initialize_parameters():
- w_conv1=weight_variable([5,5,3,32])
- b_conv1=bias_variable([32])
- w_conv2=weight_variable([5,5,32,64])
- b_conv2=bias_variable([64])
- w_fc1=weight_variable([16*16*64,512])
- b_fc1=bias_variable([512])
- w_fc2=weight_variable([512,6])
- b_fc2=bias_variable([6])
- parameters={
- "w_conv1":w_conv1,
- "b_conv1":b_conv1,
- "w_conv2":w_conv2,
- "b_conv2":b_conv2,
- "w_fc1":w_fc1,
- "b_fc1":b_fc1,
- "w_fc2":w_fc2,
- "b_fc2":b_fc2
- }
- return parameters
第四步：前行傳播過程
- def forward_propagation(X,parameters):
- w_conv1=parameters["w_conv1"]
- b_conv1=parameters["b_conv1"]
- h_conv1=tf.nn.relu(conv2d(X,w_conv1)+b_conv1)
- h_pool1=max_pool_2x2(h_conv1)
- w_conv2=parameters["w_conv2"]
- b_conv2=parameters["b_conv2"]
- h_conv2=tf.nn.relu(conv2d(h_pool1,w_conv2)+b_conv2)
- h_pool2=max_pool_2x2(h_conv2)
- w_fc1=parameters["w_fc1"]
- b_fc1=parameters["b_fc1"]
- h_pool2_flat=tf.reshape(h_pool2,[-1,16*16*64])
- h_fc1=tf.nn.relu(tf.matmul(h_pool2_flat,w_fc1)+b_fc1)
- #keep_prob=tf.placeholder(tf.float32)
- #h_fc1_drop=tf.nn.dropout(h_fc1,keep_prob)
- w_fc2=parameters["w_fc2"]
- b_fc2=parameters["b_fc2"]
- y_conv=tf.matmul(h_fc1,w_fc2)+b_fc2
- return y_conv
第五步：成本函數
- def compute_cost(y_conv,Y):
- cost=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=y_conv,labels=Y))
- return cost
第六步：梯度下降更新參數
- def random_mini_batches1(X, Y, mini_batch_size = 64, seed = 0):
- m = X.shape[0] # number of training examples
- mini_batches = []
- np.random.seed(seed)
- Y=Y.T #(1080,6)
- # Step 1: Shuffle (X, Y)
- permutation = list(np.random.permutation(m))
- shuffled_X = X[permutation,:,:,:]
- shuffled_Y = Y[permutation,:].reshape((m,Y.shape[1]))
- # Step 2: Partition (shuffled_X, shuffled_Y). Minus the end case.
- num_complete_minibatches = math.floor(m/mini_batch_size) # number of mini batches of size mini_batch_size in your partitionning
- for k in range(0, num_complete_minibatches):
- mini_batch_X = shuffled_X[k * mini_batch_size : k * mini_batch_size + mini_batch_size,:,:,:]
- mini_batch_Y = shuffled_Y[k * mini_batch_size : k * mini_batch_size + mini_batch_size,:]
- mini_batch = (mini_batch_X, mini_batch_Y)
- mini_batches.append(mini_batch)
- # Handling the end case (last mini-batch < mini_batch_size)
- if m % mini_batch_size != 0:
- mini_batch_X = shuffled_X[num_complete_minibatches * mini_batch_size : m,:,:,:]
- mini_batch_Y = shuffled_Y[num_complete_minibatches * mini_batch_size : m,:]
- mini_batch = (mini_batch_X, mini_batch_Y)
- mini_batches.append(mini_batch)
- return mini_batches
第七步：訓練模型
- def model(X_train,Y_train,X_test,Y_test,learning_rate=0.001,num_epochs=20,minibatch_size=32,print_cost=True):
- ops.reset_default_graph() #(1080, 64, 64, 3)
- tf.set_random_seed(1) #Y_train(6, 1080)
- seed=3
- (m,num_px1,num_px2,c)=X_train.shape
- n_y=Y_train.shape[0]
- costs=[]
- X,Y=create_placeholder(64,3,6)
- parameters=initialize_parameters()
- Z3=forward_propagation(X,parameters)
- cost=compute_cost(Z3,Y)
- optm=tf.train.AdamOptimizer(learning_rate).minimize(cost)
- correct_prediction=tf.equal(tf.argmax(Z3,1),tf.argmax(Y,1))#居然忘記1了，所以一直出現損失越來越小了，但是準確率卻一直是0
- accuracy=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
- with tf.Session() as sess:
- tf.global_variables_initializer().run()
- for epoch in range(num_epochs):
- epoch_cost=0
- num_minibatches=int(m/minibatch_size)
- seed+=1
- #下面輸入要求（6，,1080）格式,所以要加個轉置
- minibatches=random_mini_batches1(X_train,Y_train,minibatch_size,seed)
- for minibatch in minibatches:
- (minibatch_X,minibatch_Y)=minibatch
- _,minibatch_cost=sess.run([optm,cost],feed_dict={X:minibatch_X,Y:minibatch_Y})
- epoch_cost+=minibatch_cost/num_minibatches
- if(print_cost==True and epoch % 2==0):
- #print("Epoch",'%04d' % (epoch+1),"cost={:.9f}".format(epoch_cost))
- print("Cost after epoch %i:%f" % (epoch,epoch_cost))
- if(print_cost==True and epoch %1==0):
- costs.append(epoch_cost)
- print("Train Accuracy:",accuracy.eval({X:X_train,Y:Y_train.T}))
- print("Test Accuracy:",accuracy.eval({X:X_test,Y:Y_test.T}))
- plt.plot(np.squeeze(costs))
- plt.ylabel('cost')
- plt.xlabel('iterations(per tens)')
- plt.title("learning rate="+str(learning_rate))
- plt.show()
- parameters=sess.run(parameters)
- return parameters
- parameters=model(X_train,Y_train,X_test,Y_test)
責任編輯：龐桂玉
來源：
機器學習算法全棧工程師
