介紹

殘差網路是何凱明大神的神作，效果非常好，深度可以達到1000層。但是，其實現起來並沒有那末難，在這裡以tensorflow作為框架，實現基於mnist資料集上的殘差網路，當然只是比較淺層的。

如下圖所示：

實線的Connection部分，表示通道相同，如上圖的第一個粉色矩形和第三個粉色矩形，都是3x3x64的特徵圖，由於通道相同，所以採用計算方式為H(x)=F(x)+x

虛線的的Connection部分，表示通道不同，如上圖的第一個綠色矩形和第三個綠色矩形，分別是3x3x64和3x3x128的特徵圖，通道不同，採用的計算方式為H(x)=F(x)+Wx，其中W是卷積操作，用來調整x維度的。

根據輸入和輸出尺寸是否相同，又分為identity_block和conv_block，每種block有上圖兩種模式，三卷積和二卷積，三卷積速度更快些，因此在這裡選擇該種方式。

具體實現見如下程式碼：

#tensorflow基於mnist資料集上的VGG11網路，可以直接執行
from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf
#tensorflow基於mnist實現VGG11
mnist = input_data.read_data_sets('MNIST_data',one_hot=True)

#x=mnist.train.images
#y=mnist.train.labels
#X=mnist.test.images
#Y=mnist.test.labels
x = tf.placeholder(tf.float32,[None,784])
y = tf.placeholder(tf.float32,10])
sess = tf.InteractiveSession()

def weight_variable(shape):
#這裡是構建初始變數
 initial = tf.truncated_normal(shape,mean=0,stddev=0.1)
#建立變數
 return tf.Variable(initial)

def bias_variable(shape):
 initial = tf.constant(0.1,shape=shape)
 return tf.Variable(initial)

#在這裡定義殘差網路的id_block塊，此時輸入和輸出維度相同
def identity_block(X_input,kernel_size,in_filter,out_filters,stage,block):
 """
 Implementation of the identity block as defined in Figure 3

 Arguments:
 X -- input tensor of shape (m,n_H_prev,n_W_prev,n_C_prev)
 kernel_size -- integer,specifying the shape of the middle CONV's window for the main path
 filters -- python list of integers,defining the number of filters in the CONV layers of the main path
 stage -- integer,used to name the layers,depending on their position in the network
 block -- string/character,depending on their position in the network
 training -- train or test

 Returns:
 X -- output of the identity block,tensor of shape (n_H,n_W,n_C)
 """

 # defining name basis
 block_name = 'res' + str(stage) + block
 f1,f2,f3 = out_filters
 with tf.variable_scope(block_name):
  X_shortcut = X_input

  #first
  W_conv1 = weight_variable([1,1,f1])
  X = tf.nn.conv2d(X_input,W_conv1,strides=[1,1],padding='SAME')
  b_conv1 = bias_variable([f1])
  X = tf.nn.relu(X+ b_conv1)

  #second
  W_conv2 = weight_variable([kernel_size,f1,f2])
  X = tf.nn.conv2d(X,W_conv2,padding='SAME')
  b_conv2 = bias_variable([f2])
  X = tf.nn.relu(X+ b_conv2)

  #third

  W_conv3 = weight_variable([1,f3])
  X = tf.nn.conv2d(X,W_conv3,padding='SAME')
  b_conv3 = bias_variable([f3])
  X = tf.nn.relu(X+ b_conv3)
  #final step
  add = tf.add(X,X_shortcut)
  b_conv_fin = bias_variable([f3])
  add_result = tf.nn.relu(add+b_conv_fin)

 return add_result


#這裡定義conv_block模組，由於該模組定義時輸入和輸出尺度不同，故需要進行卷積操作來改變尺度，從而得以相加
def convolutional_block( X_input,block,stride=2):
 """
 Implementation of the convolutional block as defined in Figure 4

 Arguments:
 X -- input tensor of shape (m,depending on their position in the network
 training -- train or test
 stride -- Integer,specifying the stride to be used

 Returns:
 X -- output of the convolutional block,n_C)
 """

 # defining name basis
 block_name = 'res' + str(stage) + block
 with tf.variable_scope(block_name):
  f1,f3 = out_filters

  x_shortcut = X_input
  #first
  W_conv1 = weight_variable([1,stride,padding='SAME')
  b_conv1 = bias_variable([f1])
  X = tf.nn.relu(X + b_conv1)

  #second
  W_conv2 =weight_variable([kernel_size,padding='SAME')
  b_conv2 = bias_variable([f2])
  X = tf.nn.relu(X+b_conv2)

  #third
  W_conv3 = weight_variable([1,padding='SAME')
  b_conv3 = bias_variable([f3])
  X = tf.nn.relu(X+b_conv3)
  #shortcut path
  W_shortcut =weight_variable([1,f3])
  x_shortcut = tf.nn.conv2d(x_shortcut,W_shortcut,padding='VALID')

  #final
  add = tf.add(x_shortcut,X)
  #建立最後融合的權重
  b_conv_fin = bias_variable([f3])
  add_result = tf.nn.relu(add+ b_conv_fin)


 return add_result



x = tf.reshape(x,[-1,28,1])
w_conv1 = weight_variable([2,2,64])
x = tf.nn.conv2d(x,w_conv1,padding='SAME')
b_conv1 = bias_variable([64])
x = tf.nn.relu(x+b_conv1)
#這裡操作後變成14x14x64
x = tf.nn.max_pool(x,ksize=[1,3,padding='SAME')


#stage 2
x = convolutional_block(X_input=x,kernel_size=3,in_filter=64,out_filters=[64,64,256],stage=2,block='a',stride=1)
#上述conv_block操作後，尺寸變為14x14x256
x = identity_block(x,256,[64,block='b' )
x = identity_block(x,block='c')
#上述操作後張量尺寸變成14x14x256
x = tf.nn.max_pool(x,[1,padding='SAME')
#變成7x7x256
flat = tf.reshape(x,7*7*256])

w_fc1 = weight_variable([7 * 7 *256,1024])
b_fc1 = bias_variable([1024])

h_fc1 = tf.nn.relu(tf.matmul(flat,w_fc1) + b_fc1)
keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1,keep_prob)
w_fc2 = weight_variable([1024,10])
b_fc2 = bias_variable([10])
y_conv = tf.matmul(h_fc1_drop,w_fc2) + b_fc2


#建立損失函式，在這裡採用交叉熵函式
cross_entropy = tf.reduce_mean(
 tf.nn.softmax_cross_entropy_with_logits(labels=y,logits=y_conv))

train_step = tf.train.AdamOptimizer(1e-3).minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(y_conv,1),tf.argmax(y,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
#初始化變數

sess.run(tf.global_variables_initializer())

print("cuiwei")
for i in range(2000):
 batch = mnist.train.next_batch(10)
 if i%100 == 0:
 train_accuracy = accuracy.eval(feed_dict={
 x:batch[0],y: batch[1],keep_prob: 1.0})
 print("step %d,training accuracy %g"%(i,train_accuracy))
 train_step.run(feed_dict={x: batch[0],keep_prob: 0.5})

以上這篇tensorflow實現殘差網路方式(mnist資料集)就是小編分享給大家的全部內容了，希望能給大家一個參考，也希望大家多多支援我們。