計算圖中的操作

import numpy as np
import tensorflow as tf
sess = tf.Session()
x_vals = np.array([1., 3., 5., 7., 9.])
x_data = tf.placeholder(dtype=tf.float32)
m_const = tf.constant(3.)
my_product = tf.multiply(x_data, m_const)
for x_val in x_vals:
    print(sess.run(my_product, feed_dict={x_data:x_val}))

Tensorflow的嵌入Layer

import tensorflow as tf
sess = tf.Session()
# 創(chuàng)建數(shù)據(jù)和占位符
my_array = np.array([[1., 3., 5., 7., 9.],
                     [-2., 0., 2., 4., 6.],
                     [-6., -3., 0., 3., 6.]])
x_vals = np.array([my_array, my_array+1])
x_data = tf.placeholder(shape=(3,5), dtype=tf.float32)
# 創(chuàng)建常量矩陣
m1 = tf.constant([[1.], [0.], [-1.], [2.], [4.]]) # 5x1矩陣
m2 = tf.constant([[2.]]) # 1x1矩陣
a1 = tf.constant([[10.]]) # 1x1矩陣
# 聲明操作， 表示成計算圖
prod1 = tf.matmul(x_data, m1) # 3x5 乘以 5x1 = 3x1
prod2 = tf.matmul(prod1, m2) # 3x1 乘以標量 = 3x1
add1 = tf.add(prod2, a1)
# 賦值
for x_val in x_vals:
    print(sess.run(add1, feed_dict={x_data: x_val}))
sess.close()

注意：對于事先不知道的維度大小闯传，可以用None代替殿漠。例如：

x_data = tf.placeholder(dtype=tf.float32, shape=(3,None))

Tensorflow的多層layer

對2D圖像數(shù)據(jù)進行滑動窗口平均赴精，然后通過自定義操作層Layer返回結(jié)果。

import tensorflow as tf
import numpy as np
sess = tf.Session()
# 創(chuàng)建2D圖像绞幌，4X4像素蕾哟。
x_shape = [1, 4, 4, 1] # [batch, in_height, in_width, in_channels] tensorflow處理（圖片數(shù)量，高度、寬度谭确、顏色）思維圖像數(shù)據(jù)
x_val = np.random.uniform(size=x_shape)
# 占位符
x_data = tf.placeholder(dtype=tf.float32, shape=x_shape)
# 創(chuàng)建滑動窗口
my_filter = tf.constant(0.25, shape=[2,2,1,1]) # [filter_height, filter_width, in_channels, out_channels]
my_strides = [1, 2, 2, 1] # 長寬方向滑動步長均為2
mov_avg_layer = tf.nn.conv2d(x_data, my_filter, my_strides, 
                            padding='SAME', name='Moving_avg_Window')
# 定義一個自定義Layer帘营，操作上一步滑動窗口的2x2的返回值。
# 自定義函數(shù)將輸入張量乘以一個2X2的矩陣張量逐哈，然后每個元素加1.因為矩陣乘法只計算二維矩陣芬迄，所以裁剪多余維度（大小為1的維度）。Tensorflow通過內(nèi)建函數(shù)squeeze()函數(shù)裁剪昂秃。
def custom_layer(input_matrix):
    input_matrix_squeezed = tf.squeeze(input_matrix)
    A = tf.constant([[1., 2.], [-1., 3.]])
    b = tf.constant(1., shape=[2,2])
    temp1 = tf.matmul(A, input_matrix_squeezed)
    temp = tf.add(temp1, b) # Ax+b
    return (tf.sigmoid(temp))
# 把剛剛定義的Layer加入到計算圖中禀梳，并用tf.name_scope()命名Layer名稱。
with tf.name_scope('Custom_Layer') as scope:
    custom_layer1 = custom_layer(mov_avg_layer)
# 傳入數(shù)據(jù)械蹋，執(zhí)行
print(sess.run(custom_layer1, feed_dict={x_data:x_val}))
# 關(guān)閉會話出皇，釋放資源
sess.close()

Tensorflow實現(xiàn)損失函數(shù)

損失函數(shù)對機器學(xué)習(xí)來講非常重要，它度量模型輸出值與目標值之間的差距哗戈。

回歸問題常用損失函數(shù)

import matplotlib.pyplot as plt
import tensorflow as tf
sess = tf.Session()
# 創(chuàng)建數(shù)據(jù)
x_vals = tf.linspace(-1., 1., 500)
target = tf.constant(0.)
# L2正則損失函數(shù)：預(yù)測值與目標值差距的平方和郊艘。
# L2正則損失函數(shù)在目標值附近有更好的曲度，機器學(xué)習(xí)算法利用這點收斂唯咬，并且離目標越近收斂越慢纱注。
l2_y_vals = tf.square(target - x_vals)
l2_y_out = sess.run(l2_y_vals)
# 注意：tensorflow有內(nèi)建的L2正則形式：nn.l2_loss()。這個函數(shù)實際上是L2正則的1/2
# L1正則損失函數(shù)：預(yù)測值與目標值差值平均值
# L1正則在目標值附近不平滑胆胰，導(dǎo)致算法不能很好的收斂狞贱。
l1_y_vals = tf.abs(target - x_vals)
l1_y_out = sess.run(l1_y_vals)
# Pseudo-Huber損失函數(shù)：Huber損失函數(shù)的連續(xù)、平滑估計
# 試圖利用L1和L2正則消減極值處的陡峭蜀涨，是的目標值附近連續(xù)瞎嬉。
# 其表達式依賴參數(shù)delta
delta1 = tf.constant(0.25)
phuber1_y_vals = tf.multiply(tf.square(delta1), tf.sqrt(1.+tf.square((target-x_vals)/delta1))-1.)
phuber1_y_out = sess.run(phuber1_y_vals)
delta2 = tf.constant(5.)
phuber2_y_vals = tf.multiply(tf.square(delta2), tf.sqrt(1.+tf.square((target-x_vals)/delta2))-1.)
phuber2_y_out = sess.run(phuber2_y_vals)

關(guān)于Huber函數(shù)

L1正則在目標值處不平滑。L2正則在異常值處過大厚柳，會放大異常值的影響氧枣。因此，Huber函數(shù)在目標值附近（小于delta)是L2正則别垮，在大于delta處是L1正則便监。解決上述問題。
參考
Huber損失函數(shù)

繪圖展示回歸算法損失函數(shù)

x_array = sess.run(x_vals)
plt.plot(x_array, l2_y_out, 'b-', label='L2 Loss')
plt.plot(x_array, l1_y_out, 'r--', label='L1 Loss')
plt.plot(x_array, phuber1_y_out, 'k-', label='P-Huber Loss (0.25)')
plt.plot(x_array, phuber2_y_out, 'g:', label='P-Huber Loss (0.5)')
plt.ylim(-0.2, 0.4)
plt.legend(loc='lower right', prop={'size':11})
plt.show()

回歸算法損失函數(shù)入下圖所示：

regression_loss_function.png

可以看出碳想，L2損失函數(shù)離0點越遠烧董，損失會被2次方放大。L1損失函數(shù)在0點處不可導(dǎo)胧奔。P-Huber損失函數(shù)則在0點出是近似的L2損失函數(shù)逊移，在遠離零點處是近似的斜線。既解決了L1損失梯度下降算法可能不收斂的問題龙填，又減少了異常值的影響螟左。

分類問題常用損失函數(shù)

# 創(chuàng)建數(shù)據(jù)
x_vals = tf.linspace(-3., 5., 500)
target = tf.constant(1.)
targets = tf.fill([500,], 1)
# Hinge 損失函數(shù)：評估支持向量機算法啡浊，有時也用來評估神經(jīng)網(wǎng)絡(luò)算法。
hinge_y_vals = tf.maximum(0., 1. - tf.multiply(target, x_vals))
hinge_y_out = sess.run(hinge_y_vals)
# 兩類交叉熵損失函數(shù)(cross-entropy loss)：
xentropy_y_vals = -tf.multiply(target, tf.log(x_vals)) - tf.multiply((1.-target), tf.log(1. - x_vals))
xentropy_y_out = sess.run(xentropy_y_vals)
# Sigmoid交叉熵損失函數(shù)：與上面的交叉熵損失函數(shù)非常類似胶背，只是先將x_vals值通過sigmoid轉(zhuǎn)換在計算交叉熵巷嚣。
xentropy_sigmoid_y_vals = tf.nn.sigmoid_cross_entropy_with_logits(labels = target, logits = x_vals)
xentropy_sigmoid_y_out = sess.run(xentropy_sigmoid_y_vals)
# 加權(quán)交叉熵損失函數(shù)：Sigmoid交叉熵損失函數(shù)的加權(quán)，對正目標加權(quán)钳吟。
weight = tf.constant(0.5)
xentropy_weighted_y_vals = tf.nn.weighted_cross_entropy_with_logits(targets = targets, logits = x_vals, pos_weight = weight)
xentropy_weighted_y_out = sess.run(xentropy_weighted_y_vals)
# Softmax交叉熵損失函數(shù)：作用于非歸一化的輸出結(jié)果廷粒，只針對單個目標分類的計算損失。
unsacled_logits = tf.constant([[1., -3., 10.]])
target_dist = tf.constant([[0.1, 0.02, 0.88]])
softmax_xentropy = tf.nn.sotfmax_entropy_with_logits(logits = unscaled_logits, labels = target_dist)
print(sess.run(softmax_xentropy)
# 稀疏Softmax交叉熵損失函數(shù)
unscaled_logits = tf.constant([[1., -3., 10.]])
sparse_target_dist = tf.constant([2])
sparese_xentropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits = unscaled_logits, labels = sparse_target_dist)
print(sess.run(sparse_xentropy))

關(guān)于交叉熵的說明

1 信息量

假設(shè)我們聽到了兩件事：
A：巴西隊進入了2018世界杯決賽圈红且；B：中國隊進入了2018世界杯決賽圈坝茎。
直覺上來說，事件B比事件A包含的信息量大暇番，因為小概率事件發(fā)生了嗤放，一定是有些我們不知道的東西。因此壁酬，這樣定義信息量：
假設(shè)X是一個離散型隨機變量次酌，其取值集合為,概率分布函數(shù) ，則定義事件的信息量為：

信息量函數(shù)如下圖所示：

image

可以看出-log(x)函數(shù)刻畫的信息量舆乔，x越接近零越大岳服，越接近1越小。這里便可以理解二分類問題中的logistics回歸的損失函數(shù)-y*log(y_hat)-(1-y)*log(1-y_hat), 它會給錯誤分類很大的懲罰希俩。比如吊宋，在y=1是，y_hat如果接近0颜武，會導(dǎo)致loss很大璃搜，同樣y=0時，y_hat接近1鳞上，也會導(dǎo)致loss很大这吻。因此在最小化Loss函數(shù)時，會盡可能的將y=1的y_hat預(yù)測成1因块，y=0的y_hat預(yù)測為0。

2 熵

對于某個事件籍铁，有n中可能涡上，那么求其n中可能的信息量的期望，便是熵拒名。即熵：

3 相對熵（KL散度）

相對熵又稱KL散度吩愧，如果對于隨機變量x有兩個概率分布P(x)和Q(x),我們可以使用KL散度來衡量兩個分布的差異。KL散度的計算公式：

可見當q和p的分布越接近時增显，KL散度越小雁佳。當q和p為相同的分布是脐帝，KL散度為0。

4 交叉熵

在機器學(xué)習(xí)里糖权，p是樣本的真實分布堵腹。比如貓狗鼠的分類問題，一個樣本點(是貓）的實際分布是（1,0,0）星澳。而q是模型預(yù)測分布疚顷，比如（0.8,0.1,0.1）。那么我們模型訓(xùn)練的目標可以設(shè)置為是的p禁偎、q的KL散度最小化腿堤，即q盡可能接近真實的p分布。
而：

其中如暖，,是p分布的熵笆檀；是p和q的交叉熵。由于p是樣本的真實分布盒至，所以H(p(x))是一個常數(shù)值酗洒。那么KL散度最小化也就等價于交叉熵的最小化。

參考
關(guān)于交叉熵在loss函數(shù)中使用的理解

關(guān)于Softmax損失函數(shù)和稀疏Softmax損失函數(shù)的說明

首先妄迁，Softmax和系數(shù)Softmax損失函數(shù)最大的不同是輸入的labels不同寝蹈。對于某一個樣本點，Softmax損失函數(shù)輸入的labels是各分類的實際概率登淘，例如貓狗鼠分類箫老，就是（1,0,0）這樣的向量。對于m各樣本點黔州，輸入的labels則是一個m*3的矩陣耍鬓。而稀疏Softmax，輸入labels是實際所屬類別的index流妻，比如這里是（1,0,0）牲蜀，則輸入就是0。m個樣本點绅这，輸入是m維向量涣达，向量里面的內(nèi)容是該樣本點所屬類別的索引。
對于單個樣本點证薇，多分類的交叉熵如下：
, 其中度苔，是樣本點i各類別的實際概率分布（例如（1,0,0）），是預(yù)測概率分布（例如（0.7,0.2,0.1））浑度。對于Softmax函數(shù)寇窑，我們需要計算log(0.7),log(0.2),log(0.1)。但由于log(0.2),log(0.1)前面乘以的實際的是零箩张，實際上是沒有必要計算的甩骏。這樣窗市，Softmax損失函數(shù)就會造成算力的浪費，尤其深度學(xué)習(xí)的數(shù)據(jù)量非常大饮笛，這種浪費往往不能忍受咨察。而稀疏Softmax則只計算時的(這里即log(0.7)，可以大大的提升計算性能缎浇。因此握础，對于這種實際分布只有一個1症概，其他全為零的排他性分類問題，Softmax和稀疏Softmax損失函數(shù)沒有本質(zhì)上的區(qū)別，只是后者在計算性能上有一個優(yōu)化观堂。

評價機器學(xué)習(xí)模型的其他指標

指標	描述
	對簡單線性模型來講击吱，用于度量因變量中可由自變量解釋部分所占比例凹蜂。
RMSE (平均方差)	對連續(xù)模型來講弟头，是度量預(yù)測值和觀測值之差的樣本標準差。
混淆矩陣（Confusion matrix）	對分類模型來講踩验，以矩陣形式將數(shù)據(jù)集中的記錄按照真實的類別與預(yù)測類別兩個標準進行分析匯總鸥诽，其列代表預(yù)測類別，行代表實際類別箕憾。理想情況下牡借，混淆矩陣是對角矩陣。
查全率(Recall)	正類中有多少被正確預(yù)測（正類中被正確預(yù)測為正類的比例）袭异。
查準率（Precision）	被預(yù)測為正類的樣本中有多少是真的正類钠龙。
F值（F-score）	對于分類模型來講，F(xiàn)值是查全率和查準率的調(diào)和平均數(shù)

Tensorflow實現(xiàn)反向傳播

簡單的回歸例子

這個例子很簡單御铃，是一個一元線性回歸模型y=Ax碴里。x是均值為1，標準差0.1的標準正態(tài)分布生成的100個樣本點上真。y都是10咬腋。這樣回歸參數(shù)A應(yīng)該是10左右。

# 1 導(dǎo)入包
import numpy as np
import tensorflow as tf
# 2 創(chuàng)建會話
sess = tf.Session()
# 3 生成數(shù)據(jù)睡互，創(chuàng)建占位符和變量
x_vals = np.random.normal(1, 0.1, 100) # 均值為1根竿，標準差為0.1，100個樣本點
y_vals = np.repeat(10., 100) # 10
x_data = tf.placeholder(shape=[1], dtype=tf.float32)
y_target = tf.placeholder(shape=[1], dtype=tf.float32)
A = tf.Variable(tf.random_normal(shape=[1]))
# 4 模型
my_output = tf.multiply(x_data, A) 
# 5 增加L2正則損失函數(shù)
loss = tf.square(my_output - y_target) # 這里損失函數(shù)是單個樣本點的損失就珠，因為一次訓(xùn)練只隨機選擇一個樣本點
# 6 初始化變量
init = tf.initialize_all_variables()
sess.run(init)
# 7 聲明變量的優(yōu)化器寇壳。設(shè)置學(xué)習(xí)率。
my_opt = tf.train.GradientDescentOptimizer(learning_rate=0.02)
train_step = my_opt.minimize(loss)
# 8 訓(xùn)練算法
for i in range(100):
    rand_index = np.random.choice(100) # 隨機選擇一個樣本點
    rand_x = [x_vals[rand_index]]
    rand_y = [y_vals[rand_index]]
    sess.run(train_step, feed_dict={x_data:rand_x, y_target:rand_y})
    if (i+1)%25 == 0:
        print('Step #' + str(i) + ' A = ' + str(sess.run(A)))
        print('Loss = ' + str(sess.run(loss, feed_dict={x_data:rand_x, y_target:rand_y})))
# 9 關(guān)閉會話
sess.close()
# 輸出結(jié)果如下：
Step #24 A = [4.863781] b = 4.139231
Loss = [1.2424334]
Step #49 A = [5.316289] b = 4.6542783
Loss = [0.7101963]
Step #74 A = [5.27029] b = 4.6673064
Loss = [0.3602042]
Step #99 A = [5.211789] b = 4.67501
Loss = [0.12189686]

簡單的分類例子

這是一個簡單的二分類問題嗓违。100個樣本點九巡，其中50個由N(-1,1)生成图贸，標簽為0蹂季，50個由N(3,1)生成冕广，標簽為1。用sigmoid函數(shù)實現(xiàn)二分類問題偿洁。模型設(shè)置為sigmoid(A+x)撒汉。兩類數(shù)據(jù)中心點的中點是1，可見A應(yīng)該在-1附近涕滋。

# 1 引入python包
import tensorflow as tf
import numpy as np
# 2 創(chuàng)建會話
sess = tf.Session()
# 3 生成數(shù)據(jù)睬辐，創(chuàng)建變量和占位符
x_vals = np.concatenate((np.random.normal(-1, 1, 50),
                        np.random.normal(3, 1, 50)))
y_vals = np.concatenate((np.repeat(0., 50), 
                        np.repeat(1., 50)))
x_data = tf.placeholder(shape=[1], dtype=tf.float32)
y_target = tf.placeholder(shape=[1], dtype=tf.float32)
A = tf.Variable(tf.random_normal(mean=10, shape=[1]))

# 模型。y_pre = sigmoid(A+x)宾肺。
# 這里不必封裝sigmoid函數(shù)溯饵，因為損失函數(shù)中會實現(xiàn)此功能
my_output = tf.add(x_data, A)

# 增加一個批量維度，使其滿足損失函數(shù)的輸入要求锨用。
my_output_expanded = tf.expand_dims(my_output, 0)
y_target_expanded = tf.expand_dims(y_target, 0)

# 初始化變量A
init = tf.initialize_all_variables()
sess.run(init)

# 損失函數(shù)
xentropy = tf.nn.sigmoid_cross_entropy_with_logits(logits = my_output_expanded, 
                                                   labels = y_target_expanded)

# 優(yōu)化器
my_opt = tf.train.GradientDescentOptimizer(learning_rate = 0.05)
train_step = my_opt.minimize(xentropy)

# 迭代訓(xùn)練
for i in range(1400):
    rand_index = np.random.choice(100)
    rand_x = [x_vals[rand_index]]
    rand_y = [y_vals[rand_index]]
    
    sess.run(train_step, feed_dict={x_data:rand_x, y_target:rand_y})
    if (i+1)%200 == 0:
        print('Step #' + str(i+1) + ' A= ' + str(sess.run(A)))
        print('Loss = ' + str(sess.run(xentropy, feed_dict={x_data: rand_x,
                                                            y_target: rand_y})))
# 關(guān)閉會話
sess.close()
# 輸出結(jié)果如下：
Step #200 A= [6.4651575]
Loss = [[5.8275104]]
Step #400 A= [1.9440486]
Loss = [[1.3305019]]
Step #600 A= [-0.04775457]
Loss = [[0.11453534]]
Step #800 A= [-0.66482824]
Loss = [[0.03918179]]
Step #1000 A= [-1.0784857]
Loss = [[0.04238104]]
Step #1200 A= [-1.0975529]
Loss = [[0.06028807]]
Step #1400 A= [-1.0565817]
Loss = [[0.16332036]]

算法步驟總結(jié)

1. 生成數(shù)據(jù)或加載數(shù)據(jù)
   2.設(shè)置占位符和變量，初始化變量增拥。
   3.創(chuàng)建損失函數(shù)啄巧。
   4.定義優(yōu)化器算法。
   5.通過隨機樣本反復(fù)迭代掌栅，更新變量秩仆。

Tensorflow 實現(xiàn)隨機訓(xùn)練和批量訓(xùn)練

上面的反向傳播算法的例子，一次操作一個數(shù)據(jù)點猾封，可能會導(dǎo)致比較古怪的學(xué)習(xí)過程澄耍。本節(jié)介紹隨機批量訓(xùn)練。

import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
sess = tf.Session()

# 1 聲明批量大小忘衍。即一次傳入多少數(shù)據(jù)量
batch_size = 20
# 2 生成數(shù)據(jù)逾苫，設(shè)置占位符和變量
x_vals = np.random.normal(1, 0.1, 100)
y_vals = np.repeat(10., 100)
x_data = tf.placeholder(shape=[None, 1], dtype=tf.float32) # None會自動匹配batch大小
y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)
A = tf.Variable(tf.random_normal(shape=[1,1]))
# 3 模型
my_output = tf.matmul(x_data, A)
# 4 損失函數(shù)
loss = tf.reduce_mean(tf.square(my_output - y_target))
# 5 聲明優(yōu)化器
my_opt = tf.train.GradientDescentOptimizer(0.02)
train_step = my_opt.minimize(loss)
# 初始化變量A
init = tf.initialize_all_variables()
sess.run(init)
# 6 迭代訓(xùn)練
loss_batch = []
for i in range(100):
    rand_index = np.random.choice(100, size = batch_size)
    rand_x = np.transpose([x_vals[rand_index]])
    rand_y = np.transpose([y_vals[rand_index]])
    
    sess.run(train_step, feed_dict={x_data:rand_x, y_target:rand_y})
    if (i+1)%5==0:
        print('Step # '+ str(i+1) + ' A = ' + str(sess.run(A)))
        temp_loss = sess.run(loss, feed_dict={x_data:rand_x, y_target:rand_y})
        print('Loss = '+ str(temp_loss))
        loss_batch.append(temp_loss)
# 關(guān)閉會話
sess.close()

本段實現(xiàn)的仍是那個線性回歸的例子。唯一的不同是枚钓，上面每次優(yōu)化過程計算的損失函數(shù)只用到一個隨機樣本點铅搓。而本處用到batch_size=20個隨機樣本點，損失函數(shù)是這20個隨機樣本點損失函數(shù)的平均值搀捷。

TensorFlow實現(xiàn)創(chuàng)建分類器

這里用到iris鳶尾花數(shù)據(jù)集星掰。iris有三種花，這里只預(yù)測是否是山鳶尾嫩舟。

# 1 導(dǎo)入包氢烘、創(chuàng)建會話
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets
import tensorflow as tf
sess = tf.Session()

# 2 導(dǎo)入數(shù)據(jù)集
iris = datasets.load_iris()
binary_target = np.array([1. if x==0 else 0. for x in iris.target]) # 山鳶尾標簽設(shè)置為0
iris_2d = np.array([[x[2], x[3]] for x in iris.data])

# 3 聲明批大小、占位符和變量
batch_size = 20
x1_data = tf.placeholder(shape=[None, 1], dtype=tf.float32)
x2_data = tf.placeholder(shape=[None, 1], dtype=tf.float32)
y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)
A = tf.Variable(tf.random_normal(shape=[1,1]))
b = tf.Variable(tf.random_normal(shape=[1,1]))

# 4 模型：x1 - Ax2 -b
my_mult = tf.matmul(x2_data, A)
my_add = tf.add(my_mult, b)
my_output = tf.subtract(x1_data, my_add)

# 5 Loss函數(shù)
xentropy = tf.nn.sigmoid_cross_entropy_with_logits(labels = y_target, logits = my_output)

# 6 優(yōu)化器
my_opt = tf.train.GradientDescentOptimizer(0.05)
train_step = my_opt.minimize(xentropy)

# 7 初始化變量
init = tf.initialize_all_variables()
sess.run(init)

# 8 訓(xùn)練模型
for i in range(1000):
    rand_index = np.random.choice(len(iris_2d), size=batch_size)
    rand_x = iris_2d[rand_index]
    rand_x1 = np.array([[x[0]] for x in rand_x])
    rand_x2 = np.array([[x[1]] for x in rand_x])
    rand_y = np.array([[y] for y in binary_target[rand_index]])
    sess.run(train_step, feed_dict={x1_data:rand_x1, x2_data:rand_x2, y_target:rand_y})
    if (i+1)%200 == 0:
        print('Step #' + str(i+1) +' A= '+ str(sess.run(A)) + ',b='+str(sess.run(b)))
sess.close()
輸出如下:
Step #200 A= [[8.594328]],b=[[-3.3715847]]
Step #400 A= [[10.06079]],b=[[-4.6303725]]
Step #600 A= [[11.153477]],b=[[-5.2268066]]
Step #800 A= [[11.741766]],b=[[-5.9545264]]
Step #1000 A= [[12.346895]],b=[[-6.3250523]]

Tensorflow實現(xiàn)模型評估

回歸

這里用MSE評估

import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
sess = tf.Session()
x_vals = np.random.normal(1., 0.1, 100)
y_vals = np.repeat(10., 100)
x_data = tf.placeholder(shape=[None, 1], dtype = tf.float32)
y_target = tf.placeholder(shape=[None, 1], dtype = tf.float32)
batch_size = 25
train_indices = np.random.choice(len(x_vals), 
                                 round(len(x_vals)*0.8), replace=False) # False表示不放回
test_indices = np.array(list(set(range(len(x_vals))) - set(train_indices)))
x_vals_train = x_vals[train_indices]
x_vals_test = x_vals[test_indices]
y_vals_train = y_vals[train_indices]
y_vals_test = y_vals[test_indices]
A = tf.Variable(tf.random_normal(shape=[1,1]))

#2. 聲明算法模型家厌、損失函數(shù)和優(yōu)化器
my_output = tf.matmul(x_data, A)
loss = tf.reduce_mean(tf.square(my_output - y_target))
init = tf.initialize_all_variables()
sess.run(init)
my_opt = tf.train.GradientDescentOptimizer(0.02)
train_step = my_opt.minimize(loss)
#3. 訓(xùn)練代碼
for i in range(100):
    rand_index = np.random.choice(len(x_vals_train), size=batch_size)
    rand_x = np.transpose([x_vals_train[rand_index]])
    rand_y = np.transpose([y_vals_train[rand_index]])
    sess.run(train_step, feed_dict={x_data:rand_x, y_target:rand_y})
    if (i+1)%25 == 0:
        print('Step #'+ str(i+1) + ' A= ' + str(sess.run(A)))
        print('Loss = ' + str(sess.run(loss, feed_dict={x_data:rand_x, y_target:rand_y})))

#4. 評估訓(xùn)練模型
mse_test = sess.run(loss, feed_dict = {x_data:np.transpose([x_vals_test]),
                                       y_target:np.transpose([y_vals_test])})
mse_train = sess.run(loss, feed_dict = {x_data:np.transpose([x_vals_train]),
                                        y_target:np.transpose([y_vals_train])})
print('MSE on test:' + str(np.round(mse_test, 2 )))
print('MSE on train:' + str(np.round(mse_train, 2)))
sess.close()

分類

# 引入包
import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
# 創(chuàng)建計算圖播玖、加載數(shù)據(jù)、創(chuàng)建占位符和變量
sess = tf.Session()
batch_size = 25
x_vals = np.concatenate((np.random.normal(-1,1,50), np.random.normal(3, 1, 50))) 
y_vals = np.concatenate((np.repeat(0., 50), np.repeat(1.,50)))
x_data = tf.placeholder(shape=[None, 1], dtype=tf.float32)
y_target = tf.placeholder(shape=[None,1], dtype=tf.float32)

# 分割數(shù)據(jù)集為訓(xùn)練集和測試集
train_indices = np.random.choice(len(x_vals), 
                                 round(len(x_vals)*0.8), replace=False) # False表示不放回
test_indices = np.array(list(set(range(len(x_vals))) - set(train_indices)))
x_vals_train = x_vals[train_indices]
x_vals_test = x_vals[test_indices]
y_vals_train = y_vals[train_indices]
y_vals_test = y_vals[test_indices]
A = tf.Variable(tf.random_normal(mean=10,shape=[1,1]))

# 設(shè)置模型
my_output = tf.add(x_data,A)

# 初始化變量
init = tf.initialize_all_variables()
sess.run(init)

# 損失函數(shù)和優(yōu)化器
xentropy = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits = my_output, labels=y_target))
my_opt = tf.train.GradientDescentOptimizer(0.05)
train_step = my_opt.minimize(xentropy)

# 訓(xùn)練模型
for i in range(1800):
    rand_index = np.random.choice(len(x_vals_train), size=batch_size)
    rand_x = np.transpose([x_vals_train[rand_index]])
    rand_y = np.transpose([y_vals_train[rand_index]])
    sess.run(train_step, feed_dict={x_data:rand_x,
                                    y_target:rand_y})
    if (i+1)%200 ==0:
        print('Step #'+ str(i+1) + ' A= ' + str(sess.run(A)))
        print('Loss = ' + str(sess.run(xentropy, feed_dict={x_data:rand_x, y_target:rand_y})))
        
# 模型評估
y_prediction = tf.round(tf.nn.sigmoid(tf.add(x_data, A)))
correct_prediction = tf.squeeze(tf.equal(y_prediction, y_target))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
acc_value_test = sess.run(accuracy, feed_dict={x_data:np.transpose([x_vals_test]), 
                                               y_target:np.transpose([y_vals_test])})
acc_value_train = sess.run(accuracy, feed_dict={x_data:np.transpose([x_vals_train]), 
                                                y_target:np.transpose([y_vals_train])})
print('Accuracy on train set:' + str(acc_value_train))
print('Accuracy on test set:' + str(acc_value_test))


# 畫圖
A_result = -sess.run(A)
bins = np.linspace(-5, 5, 50)
plt.hist(x_vals[0:50], bins, alpha=0.5, label='N(-1,1)', color='blue')
plt.hist(x_vals[50:100], bins[0:50], alpha=0.5, label='N(2,1)', color='red')
plt.axvline(A_result, color = 'k', ls = '--', linewidth=1, label='A='+str(np.round(A_result, 2)))
plt.legend(loc='upper right')
plt.show()
sess.close()