|
首先 上面講了神經(jīng)元 Y=WX+B ，通過輸入的參數(shù)X ===========》Y 深度學習 每一個batch來說 其實就是 多項公式
我們知道 在數(shù)學里面 求多項公式 其實 就是 矩陣 W 矩陣 乘與 X 加上 B 矩陣 = Y矩陣 ，矩陣 二元數(shù)組在tensorflow 也是一個tensor ndarray , 通常 我們知道 因為relu 收斂效果要比sigmod 與tanh 要好,，所以在cnn中常用relu，所以 其實 對于輸出o=relu(wx+b) ,
1.TensorFlow卷積
比如 下面 是tensorflow卷積定義 relu(W*X+B) W 矩陣 * X矩陣 + B矩陣 = W 權重variable變量 * X (placeholder占位符外部輸入)variable變量 + B偏重變量，因為深度學習 會自動 不斷地計算loss損失 BP 來調整 w b 所以 w b初始化 可以隨便 全部都是0 都行 ,，所以 其實 就是 X 以及 Y 對于 X來說其實我們知道 就是 我們圖像數(shù)據(jù) Y 是圖像的標簽，但是Y需要轉為數(shù)學可以計算的值,，所以采用one-hot 數(shù)組記錄 標簽的索引就行,，比如 xx1 xx2 xx3 相應的y1=[1,0,0] y2=[0 1 0] y3=[0 0 1]
那么 其實 就是 X 圖像的像素 通過外部輸入 placeholder占位符 Y值 外部輸入 通過 placeholder占位符
我們知道 W*X 矩陣 相乘 必須 符合 MXN NXM =MXM 也就是說W的 列 必須 與 X的行數(shù)目相同 這是要注意的，所以上一張shape來規(guī)范維度計算 ,，下面是一個卷積層 定義 relu(wx+b) 下面是tensorflow來表示relu(wx+b)的公式
其中要注意參數(shù) strides 是卷積滑動的步長 你可以配置更多的系數(shù),，
def conv2d(x, w, b):
return tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(x, w, strides=[1, 1, 1, 1], padding='SAME'),b))
上面我們理解了， 其實就是 W矩陣 * X矩陣 +B 矩陣 =Y矩陣
Y矩陣 好算 ,，W矩陣 +B矩陣 已知 可以隨意后面要bp調整,。那么X矩陣 是圖像 也就是說輸入的X
x = tf.placeholder(tf.float32, [None, w*h]) #w*h 因為批次訓練 數(shù)據(jù)可以任意所以第一個是None ，第二個圖像是個w * h的圖像 ,，可以展開得到 w * h 的數(shù)組
我們知道 卷積運算 其實是卷積的個數(shù) M 展開的卷積核長寬維度 K * 卷積能夠提取的數(shù)目 K * 提取圖像的維度N =MXN
也就說可以通過 卷積核 讓圖像 W*H 轉變成 一個 卷積的個數(shù) 的行 ,，N 為提取圖像卷積特征的每一行數(shù)據(jù)的的矩陣
還是遵循WX+B
我們定義好W
我們可以把整個網(wǎng)絡看成wx+b 忽略掉那些relu 等等 其實 就是一個y=wx+b 我們知道輸入 是上面的
x = tf.placeholder(tf.float32, [None, w*h])
y = tf.placeholder(tf.float32, [None, ysize])#y的數(shù)目個數(shù) 比如3個類 就是3
那么 一個x 需 要 * W = y 計入batch為50 y為10 那么[50,224*224] * W= [50 ,10]
那么W 需要是一個[224*224，10] 的矩陣 ,，也就是說 至少224*224*10*50 個連接
下面繼續(xù) 講X [None ,w*h] 對于每一個 w*h 是一個矩陣 每一層的w 也是一個矩陣 每一層的 b也是一個矩陣 ,，每一層的輸出y1 也是一個矩陣 y=[w*h]*w+b 為了減少系數(shù)，我們使用卷積,，把它轉換成MXN的值 ,，這里就是跟全連接層的不同,，使用了卷積轉換成了一個MXN的卷積特征 而全連接層就是 y=wx+b (這里省略了那些relu(wx+b) tanh(wx+b))
所以我們現(xiàn)在來看看每一層的w 定義
因為卷積層的w是需要 與 w*h 提取的MXK來做矩陣相乘 所以 他是跟卷積核相關 以及 輸入 輸出 相關，對于每一張圖像
輸入為1 輸出分解為多個輸出用于 第二層運算
wc=tf.Variable(tf.random_normal([3, 3, 1, 64]) #3 3 分別為3x3大小的卷積核 1位輸入數(shù)目 因為是第一層所以是1 輸出我們配置的64
所以我們知道了 如果下一次卷積wc2=[5,5,64,256] //5x5 是我們配置的卷積核大小,，第三位表示輸入數(shù)目 我們通過上面知道 上面的輸出 也就是下一層的輸入 所以 就是64 了輸出我們定義成256 這個隨你喜好,，關鍵要迭代看效果，一般都是某一個v*v的值
這樣我們知道了 wc*(卷積得到的x) + b =y1下一層輸入,，我們也能知道 一下層輸入 mxnxo 分別為輸出O個卷積核特征MXN 我們也能知道b 大小 那個肯定跟O一樣,，比如上面是64輸出，所以
b1=tf.Variable(tf.random_normal([64]))
同樣可以知道b2=[256]
下面我們講一講池化層pool 池化層 不會減少輸出,，只會把MXNXO ,，把卷積提取的特征 做進一步卷積 取MAX AVG MIN等 用局部代替整理進一步縮小特征值大小
下面是一個用kxk 的核做maxpooling的定義
def max_pool_kxk(x):
return tf.nn.max_pool(x, ksize=[1, k, k, 1],
strides=[1, k, k, 1], padding='SAME')
這樣我們可以定義一個簡單的CNN了
c1 = tf.nn.relu(tf.nn.conv2d(X, w, [1, 1, 1, 1], 'SAME'))
m1 = tf.nn.max_pool(l1a, ksize=[1, k, k, 1],
strides=[1, k, k, 1], padding='SAME')
d1 = tf.nn.dropout(l1, p_keep_conv)
c2 = tf.nn.relu(tf.nn.conv2d(l1, w2, [1, 1, 1, 1], 'SAME'))
m2 = tf.nn.max_pool(l2a, ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1], padding='SAME')
d2= tf.nn.dropout(l2, p_keep_conv)
c3 = tf.nn.relu(tf.nn.conv2d(l2, w3, [1, 1, 1, 1], 'SAME'))
m3 = tf.nn.max_pool(l3a, ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1], padding='SAME')
d3 = tf.nn.dropout(tf.reshape(l3, [-1, w4.get_shape().as_list()[0]]), p_keep_conv)
#d3表示倒數(shù)第二層的輸出 也就是倒數(shù)第一層一層的輸入x 我們代入 y=wx+b 也就是w*x=w4*d3+b
y = tf.nn.bias_add(tf.matmul(d3, w4),b4))#matmul 顧名思義mat矩陣mul相乘 matmul w*x
上面的用圖表示就是 X,Y ========>conv1======>relu======>drop梯度下降=======》conv2===>relu2===drop2====>conv3====>relu======>drop===full全連接 （y=wx+b）
官方給了 一個example 關于alexnet的 我貼一下代碼 ，大家只要理解了上面講的內容 就可以知道怎么稍微修改 就可以自己定義一個 CNN網(wǎng)絡了
http://www./tfdoc/tutorials/deep_cnn.html
http://www./tfdoc/tutorials/mnist_pros.html
大家可以去執(zhí)行一下,，這個我執(zhí)行多次了,，下一章DNN ，DNN 就是CNN去掉卷積層 ,，的深度學習網(wǎng)絡 通過全連接層 梯度下降層構成的的DNN網(wǎng)絡
大家有疑問就是后面訓練完了怎么使用,，其實訓練完了 保存每一層的w b參數(shù) 起來就是一個網(wǎng)絡模型model 然后使用model進行預測 分類了，這個后面要講怎么保存并使用model
不知道怎么上傳附件,。麻煩 懶得放外聯(lián)了 ,。其中input_data模塊
地址為 https://github.com/tensorflow/tensorflow/blob/master/tensorflow/examples/tutorials/mnist/input_data.py
import input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)
import tensorflow as tf
# Parameters
learning_rate = 0.001
training_iters = 100000
batch_size = 128
display_step = 10
# Network Parameters
n_input = 784 # MNIST data input (img shape: 28*28)
n_classes = 10 # MNIST total classes (0-9 digits)
dropout = 0.75 # Dropout, probability to keep units
# tf Graph input
x = tf.placeholder(tf.float32, [None, n_input])
y = tf.placeholder(tf.float32, [None, n_classes])
keep_prob = tf.placeholder(tf.float32) #dropout (keep probability)
# Create model
def conv2d(img, w, b):
return tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(img, w, strides=[1, 1, 1, 1], padding='SAME'),b))
def max_pool(img, k):
return tf.nn.max_pool(img, ksize=[1, k, k, 1], strides=[1, k, k, 1], padding='SAME')
def conv_net(_X, _weights, _biases, _dropout):
# Reshape input picture
_X = tf.reshape(_X, shape=[-1, 28, 28, 1])
# Convolution Layer
conv1 = conv2d(_X, _weights['wc1'], _biases['bc1'])
# Max Pooling (down-sampling)
conv1 = max_pool(conv1, k=2)
# Apply Dropout
conv1 = tf.nn.dropout(conv1, _dropout)
# Convolution Layer
conv2 = conv2d(conv1, _weights['wc2'], _biases['bc2'])
# Max Pooling (down-sampling)
conv2 = max_pool(conv2, k=2)
# Apply Dropout
conv2 = tf.nn.dropout(conv2, _dropout)
# Fully connected layer
dense1 = tf.reshape(conv2, [-1, _weights['wd1'].get_shape().as_list()[0]]) # Reshape conv2 output to fit dense layer input
dense1 = tf.nn.relu(tf.add(tf.matmul(dense1, _weights['wd1']), _biases['bd1'])) # Relu activation
dense1 = tf.nn.dropout(dense1, _dropout) # Apply Dropout
# Output, class prediction
out = tf.add(tf.matmul(dense1, _weights['out']), _biases['out'])
return out
# Store layers weight & bias
weights = {
'wc1': tf.Variable(tf.random_normal([5, 5, 1, 32])), # 5x5 conv, 1 input, 32 outputs
'wc2': tf.Variable(tf.random_normal([5, 5, 32, 64])), # 5x5 conv, 32 inputs, 64 outputs
'wd1': tf.Variable(tf.random_normal([7*7*64, 1024])), # fully connected, 7*7*64 inputs, 1024 outputs
'out': tf.Variable(tf.random_normal([1024, n_classes])) # 1024 inputs, 10 outputs (class prediction)
}
biases = {
'bc1': tf.Variable(tf.random_normal([32])),
'bc2': tf.Variable(tf.random_normal([64])),
'bd1': tf.Variable(tf.random_normal([1024])),
'out': tf.Variable(tf.random_normal([n_classes]))
}
# Construct model
pred = conv_net(x, weights, biases, keep_prob)
# Define loss and optimizer
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred, y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
# Evaluate model
correct_pred = tf.equal(tf.argmax(pred,1), tf.argmax(y,1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
# Initializing the variables
init = tf.initialize_all_variables()
# Launch the graph
with tf.Session() as sess:
sess.run(init)
step = 1
# Keep training until reach max iterations
while step * batch_size < training_iters:
batch_xs, batch_ys = mnist.train.next_batch(batch_size)
# Fit training using batch data
sess.run(optimizer, feed_dict={x: batch_xs, y: batch_ys, keep_prob: dropout})
if step % display_step == 0:
# Calculate batch accuracy
acc = sess.run(accuracy, feed_dict={x: batch_xs, y: batch_ys, keep_prob: 1.})
# Calculate batch loss
loss = sess.run(cost, feed_dict={x: batch_xs, y: batch_ys, keep_prob: 1.})
print "Iter " + str(step*batch_size) + ", Minibatch Loss= " + "{:.6f}".format(loss) + ", Training Accuracy= " + "{:.5f}".format(acc)
step += 1
print "Optimization Finished!"
# Calculate accuracy for 256 mnist test images
print "Testing Accuracy:", sess.run(accuracy, feed_dict={x: mnist.test.images[:256], y: mnist.test.labels[:256], keep_prob: 1.})
運行截圖========== accuracy為精度 loss為損失函數(shù)，有多種計算方式 這里是 交叉熵” ,。下面看到 accuracy第三次為0.40625 通過多次迭代后 不斷的提高,，運行多次 最后保存精度最高的那個為模型就好了，這里因為alexnet本來就是一個很簡單的模型,，所以精度也不怎么高,。 我服務器是1核1G的CPU服務器所以很慢。懶得等他運行完了
精度 在 增加,。,。。
好像最后是99,。2% 精確度 情況 ,，手寫識別 0-9 這里有98.4%了
好吧。這次運行 精度大概97.6左右 下一章節(jié) 我修改一下系數(shù)以及 加幾層層網(wǎng)絡試試效果 ,，
|
