代價函數+擬合+優化器

一.代價函數

1.二次代價函數

（1）定義：

其中，C表示代價函數，x表示樣本，y表示實際值，a表示輸出值，n表示樣本的總數。爲簡單起見，同樣一個樣本爲例進行說明，此時二次代價函數爲：

a=σ(z), z=∑Wj*Xj+b

σ() 是激活函數

（2）假如我們使用梯度下降法(Gradient descent)來調整權值參數的大小，權值w和偏置b的梯度推導如下：

其中，z表示神經元的輸入，σ表示激活函數。w和b的梯度跟激活函數的梯度成正比，激活函數的梯度越大，w和b的大小調整得越快，訓練收斂得就越快。

（3）假設我們的激活函數是sigmoid函數：

2.交叉熵代價函數（cross-entropy）:

(1)換一個思路，我們不改變激活函數，而是改變代價函數，改用交叉熵代價函數：

其中，C表示代價函數，x表示樣本，y表示實際值，a表示輸出值，n表示樣本的總數。

a=σ(z), z=∑Wj*Xj+b

權值和偏置值的調整與無關,另外，梯度公式中的表示輸出值與實際值的誤差。所以當誤差越大時，梯度就越大，參數w和b的調整就越快，訓練的速度也就越快。

如果輸出神經元是線性的，那麼二次代價函數就是一種合適的選擇。如果輸出神經元是S型函數，
那麼比較適合用交叉熵代價函數。

3.對數釋然代價函數（log-likelihood cost）:

對數釋然函數常用來作爲softmax迴歸的代價函數，如果輸出層神經元是sigmoid函數，可以採用交叉熵代價函數。而深度學習中更普遍的做法是將softmax作爲最後一層，此時常用的代價函數是對數釋然代價函數。

對數似然代價函數與softmax的組合和交叉熵與sigmoid函數的組合非常相似。對數釋然代價函數在二分類時可以化簡爲交叉熵代價函數的形式。

在Tensorflow中用：
tf.nn.sigmoid_cross_entropy_with_logits()來表示跟sigmoid搭配使用的交叉熵。

tf.nn.softmax_cross_entropy_with_logits()來表示跟softmax搭配使用的交叉熵。

二.擬合

1.擬合（迴歸）

2.擬合（分類）

3.防止過擬合

（1）增加數據集

（2）正則化方法

（3）dropout

隱藏部分神經元，只讓部分神經元進行工作。

4.代碼

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
# 載入數據
mnist = input_data.read_data_sets('F:\Pycharm projection\MNIST_data', one_hot=True)
# 每個批次的大小
batch_size = 100
# 計算一共有多少批次
n_batch = mnist.train.num_examples // batch_size
# print(n_batch)

# 定義3個placehoder
x = tf.placeholder(tf.float32, [None, 784])    # 行與批次有關，一會兒計算之後傳入，列是一張是28*28像素
y = tf.placeholder(tf.float32, [None, 10])     # y 是標籤0-9包括10類
keep_prob = tf.placeholder(tf.float32)

# 創建一個簡單的神經網絡
"""
只用到輸入層和輸出層，不加隱藏層
輸入層：784個神經元
輸出層：10個標籤，就10個神經元
增加中間層
"""
# w1 = tf.Variable(tf.zeros([784,10]))   # 權值
# b1 = tf.Variable(tf.zeros([10]))     # 偏置值
# 使用截斷的正太分佈（tf.truncated_normal）來進行初始化，標準差（stddev）是0.1
w1 = tf.Variable(tf.truncated_normal([784,2000],stddev= 0.1))
b1 = tf.Variable(tf.zeros([2000])+0.1)
L1 = tf.nn.tanh(tf.matmul(x,w1)+b1)      # 中間層，使用雙曲正切函數
L1_drop = tf.nn.dropout(L1,keep_prob)    # L1某一個層神經元的輸出，keep_prob設置百分之多少的神經元是工作的。
# 增加隱藏層
w2 = tf.Variable(tf.truncated_normal([2000,2000],stddev= 0.1))
b2 = tf.Variable(tf.zeros([2000])+0.1)
L2 = tf.nn.tanh(tf.matmul(L1_drop,w2)+b2)      # 中間層，使用雙曲正切函數
L2_drop = tf.nn.dropout(L2,keep_prob)    # L1某一個層神經元的輸出，keep_prob設置百分之多少的神經元是工作的。

w3 = tf.Variable(tf.truncated_normal([2000,1000],stddev= 0.1))
b3 = tf.Variable(tf.zeros([1000])+0.1)
L3 = tf.nn.tanh(tf.matmul(L2_drop,w3)+b3)      # 中間層，使用雙曲正切函數
L3_drop = tf.nn.dropout(L3,keep_prob)    # L1某一個層神經元的輸出，keep_prob設置百分之多少的神經元是工作的。

w4 = tf.Variable(tf.truncated_normal([1000,10],stddev= 0.1))
b4 = tf.Variable(tf.zeros([10])+0.1)
prediction = tf.nn.softmax(tf.matmul(L3_drop, w4)+b4)   # 預測值，使用sofrmax函數

# 二次代價函數
# loss = tf.reduce_mean(tf.square(y-prediction))
# 對數釋然代價函數(交叉熵)
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=prediction))
# 定義一個梯度下降發來訓練優化器
train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)   # 給出學習率0.2

# 初始化變量
init =tf.global_variables_initializer()

"""
模型訓練好之後，要測試下，模型的準確率
定義求準確率的方法
"""
# 結果存在一個布爾型列表中
# argmax返回一維張量中最大值所在的位置
correct_prediction = tf.equal(tf.argmax(y, 1),tf.argmax(prediction, 1))
# 求準確率
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))  # cast作用把布爾型轉成32位的float

with tf.Session() as sess:
    sess.run(init)
    for epoch in range(11):
        for batch in range(n_batch):
            # 獲得一個批次（100張圖片），它的大小100；圖片數據保存在 ：batch_xs,標籤保存在：batch_ys
            batch_xs,batch_ys = mnist.train.next_batch(batch_size)
            sess.run(train_step,feed_dict={x:batch_xs, y:batch_ys,keep_prob:1.0})   # keep_prob=1.0 表示所有的神經元都工作
        # 訓練一個週期之後測試一下準確率
        test_acc = sess.run(accuracy,feed_dict={x:mnist.test.images, y:mnist.test.labels,keep_prob:1.0})
        train_acc = sess.run(accuracy,feed_dict={x:mnist.train.images, y:mnist.train.labels,keep_prob:1.0})
        print("Iter"+str(epoch),"Testing accuracy"+str(test_acc),"Train accuracy"+str(train_acc))

keep_prob=1.0 代碼所有神經元都工作運行結果：

Iter0 Testing accuracy0.8628 Train accuracy0.8719818
Iter1 Testing accuracy0.9579 Train accuracy0.97296363
Iter2 Testing accuracy0.9622 Train accuracy0.9818909
Iter3 Testing accuracy0.9664 Train accuracy0.98636365
Iter4 Testing accuracy0.9679 Train accuracy0.9886182
Iter5 Testing accuracy0.9694 Train accuracy0.9900182
Iter6 Testing accuracy0.9703 Train accuracy0.9910909
Iter7 Testing accuracy0.9712 Train accuracy0.99183637
Iter8 Testing accuracy0.9709 Train accuracy0.99243635
Iter9 Testing accuracy0.972 Train accuracy0.9928909

Iter10 Testing accuracy0.9706 Train accuracy0.9932727

with tf.Session() as sess:
    sess.run(init)
    for epoch in range(11):
        for batch in range(n_batch):
            # 獲得一個批次（100張圖片），它的大小100；圖片數據保存在 ：batch_xs,標籤保存在：batch_ys
            batch_xs,batch_ys = mnist.train.next_batch(batch_size)
            sess.run(train_step,feed_dict={x:batch_xs, y:batch_ys,keep_prob:0.7})   # keep_prob=1.0 表示所有的神經元都工作
        # 訓練一個週期之後測試一下準確率
        test_acc = sess.run(accuracy,feed_dict={x:mnist.test.images, y:mnist.test.labels,keep_prob:1.0})
        train_acc = sess.run(accuracy,feed_dict={x:mnist.train.images, y:mnist.train.labels,keep_prob:1.0})
        print("Iter"+str(epoch),"Testing accuracy"+str(test_acc),"Train accuracy"+str(train_acc))

keep_prob=0.7,有70%的神經元工作，運行結果：

Iter0 Testing accuracy0.9158 Train accuracy0.9109455
Iter1 Testing accuracy0.9295 Train accuracy0.92716366
Iter2 Testing accuracy0.9344 Train accuracy0.9339455
Iter3 Testing accuracy0.9408 Train accuracy0.94078183
Iter4 Testing accuracy0.9434 Train accuracy0.9437818
Iter5 Testing accuracy0.9472 Train accuracy0.9490727
Iter6 Testing accuracy0.9507 Train accuracy0.9518545
Iter7 Testing accuracy0.9528 Train accuracy0.95467275
Iter8 Testing accuracy0.9526 Train accuracy0.95476365
Iter9 Testing accuracy0.9552 Train accuracy0.95885456

Iter10 Testing accuracy0.9576 Train accuracy0.9608

5.可以選擇不同的優化器

# # 定義一個梯度下降發來訓練優化器
# train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)   # 給出學習率0.2

train_step = tf.train.AdamOptimizer(1e-2).minimize(loss)  # 1e-2代表10的負2次方

Iter0 Testing accuracy0.098 Train accuracy0.09898182
Iter1 Testing accuracy0.098 Train accuracy0.09898182
Iter2 Testing accuracy0.098 Train accuracy0.09898182
Iter3 Testing accuracy0.098 Train accuracy0.09898182
Iter4 Testing accuracy0.098 Train accuracy0.09898182
Iter5 Testing accuracy0.098 Train accuracy0.09898182
Iter6 Testing accuracy0.098 Train accuracy0.09898182
Iter7 Testing accuracy0.098 Train accuracy0.09898182
Iter8 Testing accuracy0.098 Train accuracy0.09898182
Iter9 Testing accuracy0.098 Train accuracy0.09898182

Iter10 Testing accuracy0.098 Train accuracy0.09898182

6.學習效率：隨迭代次數學習效率減小

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
# 載入數據
mnist = input_data.read_data_sets('F:\Pycharm projection\MNIST_data', one_hot=True)
# 每個批次的大小
batch_size = 100
# 計算一共有多少批次
n_batch = mnist.train.num_examples // batch_size
# print(n_batch)

# 定義3個placehoder
x = tf.placeholder(tf.float32, [None, 784])    # 行與批次有關，一會兒計算之後傳入，列是一張是28*28像素
y = tf.placeholder(tf.float32, [None, 10])     # y 是標籤0-9包括10類
keep_prob = tf.placeholder(tf.float32)
lr = tf.Variable(0.001,dtype=tf.float32)  # 初始學習效率0.001，後面的可以改變
# 創建一個簡單的神經網絡
"""
只用到輸入層和輸出層，不加隱藏層
輸入層：784個神經元
輸出層：10個標籤，就10個神經元
增加中間層
"""
# w1 = tf.Variable(tf.zeros([784,10]))   # 權值
# b1 = tf.Variable(tf.zeros([10]))     # 偏置值
# 使用截斷的正太分佈（tf.truncated_normal）來進行初始化，標準差（stddev）是0.1
w1 = tf.Variable(tf.truncated_normal([784,500],stddev= 0.1))
b1 = tf.Variable(tf.zeros([500])+0.1)
L1 = tf.nn.tanh(tf.matmul(x,w1)+b1)      # 中間層，使用雙曲正切函數
L1_drop = tf.nn.dropout(L1,keep_prob)    # L1某一個層神經元的輸出，keep_prob設置百分之多少的神經元是工作的。
# 增加隱藏層
w2 = tf.Variable(tf.truncated_normal([500,300],stddev= 0.1))
b2 = tf.Variable(tf.zeros([300])+0.1)
L2 = tf.nn.tanh(tf.matmul(L1_drop,w2)+b2)      # 中間層，使用雙曲正切函數
L2_drop = tf.nn.dropout(L2,keep_prob)    # L1某一個層神經元的輸出，keep_prob設置百分之多少的神經元是工作的。

w3 = tf.Variable(tf.truncated_normal([300,10],stddev= 0.1))
b3 = tf.Variable(tf.zeros([10])+0.1)
prediction = tf.nn.softmax(tf.matmul(L2_drop, w3)+b3)   # 預測值，使用sofrmax函數

# 二次代價函數
# loss = tf.reduce_mean(tf.square(y-prediction))
# 對數釋然代價函數(交叉熵)
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=prediction))
# # 定義一個梯度下降發來訓練優化器
# train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)   # 給出學習率0.2

train_step = tf.train.AdamOptimizer(lr).minimize(loss)  # 1e-2代表10的負2次方

# 初始化變量
init =tf.global_variables_initializer()

"""
模型訓練好之後，要測試下，模型的準確率
定義求準確率的方法
"""
# 結果存在一個布爾型列表中
# argmax返回一維張量中最大值所在的位置
correct_prediction = tf.equal(tf.argmax(y, 1),tf.argmax(prediction, 1))
# 求準確率
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))  # cast作用把布爾型轉成32位的float

with tf.Session() as sess:
    sess.run(init)
    for epoch in range(51):
        sess.run(tf.assign(lr,0.001*(0.95**epoch)))   # 0.95**epoch 代表迭代幾次就0.95的幾次方 *0.001  賦給lr
        for batch in range(n_batch):
            # 獲得一個批次（100張圖片），它的大小100；圖片數據保存在 ：batch_xs,標籤保存在：batch_ys
            batch_xs,batch_ys = mnist.train.next_batch(batch_size)
            sess.run(train_step,feed_dict={x:batch_xs, y:batch_ys,keep_prob:1.0})   # keep_prob=1.0 表示所有的神經元都工作
        learning_rate = sess.run(lr)
        # 訓練一個週期之後測試一下準確率
        test_acc = sess.run(accuracy,feed_dict={x:mnist.test.images, y:mnist.test.labels,keep_prob:1.0})
        print("Iter"+str(epoch),"Testing accuracy"+str(test_acc),"Learning Rate"+str(learning_rate))

Iter0 Testing accuracy0.9543 Learning Rate0.001
Iter1 Testing accuracy0.96 Learning Rate0.00095
Iter2 Testing accuracy0.9672 Learning Rate0.0009025
Iter3 Testing accuracy0.9711 Learning Rate0.000857375
Iter4 Testing accuracy0.9723 Learning Rate0.00081450626
Iter5 Testing accuracy0.9746 Learning Rate0.0007737809
Iter6 Testing accuracy0.9743 Learning Rate0.0007350919
Iter7 Testing accuracy0.9776 Learning Rate0.0006983373
Iter8 Testing accuracy0.9777 Learning Rate0.0006634204
Iter9 Testing accuracy0.9783 Learning Rate0.0006302494
Iter10 Testing accuracy0.978 Learning Rate0.0005987369
Iter11 Testing accuracy0.9785 Learning Rate0.0005688001
Iter12 Testing accuracy0.9783 Learning Rate0.0005403601
Iter13 Testing accuracy0.9809 Learning Rate0.0005133421
Iter14 Testing accuracy0.9811 Learning Rate0.000487675
Iter15 Testing accuracy0.9781 Learning Rate0.00046329122

三.優化器（Optimizer）:
tf.train.GradientDescentOptimizer

tf.train.AdadeltaOptimizer

tf.train.AdagradOptimizer

tf.train.AdagradDAOptimizer

tf.train.MomentumOptimizer

tf.train.AdamOptimizer

tf.train.FtrlOptimizer

tf.train.ProximalGradientDescentOptimizer

tf.train.ProximalAdagradOptimizer

tf.train.RMSPropOptimizer

代價函數+擬合+優化器

win10 Anaconda3 安裝tensorflow CPU

爬蟲學習1.Requests庫詳解

win10下安裝pytorch

代價函數+擬合+優化器

爬蟲實戰篇：Requests+正則表達式爬取貓眼電影

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結