TensorFlow可以將一個計算圖劃分成多個子圖，然後並行地在多個CPU或者GPU上執行
創建一個計算圖並在會話中執行
import tensorflow as tf
x = tf.Variable(3,name="x")
y = tf.Variable(4,name="y")
f = x*x*y + y +2
下面的代碼創建一個會話，初始化所有變量，然後求值，最後F關閉整個會話
sess = tf.Session()
sess.run(x.initializer)
sess.run(y.initializer)
result = sess.run(f)
print(f)
sess.close()
等價於
with tf.Session() as sess:
x.initializer.run()
y.initializer.run()
result = f.eval()
還可以使用global_variables_initializer()函數來完成同樣的動作.這個操作不會立刻初始化，只是
在圖中創建了一個節點，這個節點會在會話執行時初始化所有變量。
init = tf.global_variables_initializer()
with tf.Session() as sess:
init.run()
result = f.eval()
例子：
#基本計算單元賦值
import tensorflow as tf
w = tf.Variable([[0.5,1.0]])
x = tf.Variable([2.0],[1.0])
y = tf.matmul(w,x) // 創建w,x,y變量
init_op = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init_op) //初始化 運行
print(y.eval()) #打印數值需要.eval()
#常用構造數據
### 'tensor' is [[1,2,3], [4,5,6]] ###
tf.zeros([3,4], int32) ==>[[0,0,0,0],[0,0,0,0],[0,0,0,0]]
tf.zeros_like(tensor) ==>[[0,0,0],[0,0,0]]
tf.ones([2,3], int32) ==>[[0,0,0],[0,0,0]]
tf.ones_like(tensor) ==>[[1,1,1],[1,1,1]]
tensor = tf.constant([1,2,3,4,5,6,7]) =>[1 2 3 4 5 6 7]
tensor = tf.constant(-1.0,shape=[2,3]) =>[[-1. -1. -1.] [-1. -1. -1.]]
tf.linspace(10.0, 12.0, 3, name="linspace") =>[10.0 11.0 12.0]
tf.range(start,limit,delta) ==> [3,6,9,12,15] #'start'3 'limit'18 'delta'3
norm = tf.random_normal([2,3], mean=-1, stddev=4) #均值爲-1，方差爲4的分佈
c=tf.constant([1,2],[3,4],[5,6])
shuff = tf.random_shuffle(c) #洗牌
#tensorflow實現0連續加三次1
state = tf.Variable(0)
new_value = tf.add(state, tf.constant(1))
update = tf.assign(state, new_value) #把新值賦給state
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
print(sess.run(state))
for _ in range(3):
sess.run(update)
print(sess.run(state))
#Saver保存
w = tf.Variable([[0.5, 1.0]])
x = tf.Variable([[2.0], [1.0]])
y = tf.matmul(w, x)
init_op = tf.global_variables_initializer()
saver = tf.train.Saver()
with tf.Session() as sess:
sess.run(init_op)
#保存變量到磁盤上
save_path = saver.save(sess, "C://tensorflow//model//test")
print("Model saved in file:", save_path)
#numpy數據轉tensorflow
import numpy as np
a = np.zeros((3,3))
ta = tf.convert_to_tensor(a)
with tf.Session() as sess:
print(sess.run(ta))
#先定義空白模塊後賦值
input1 = tf.placeholder(tf.float32)
input2 = tf.placeholder(tf.float32)
output = tf.mul(input1, input2)
with tf.Session() as sess:
print(sess.run([output],feed_dict={input1:[7.], input2:[2.]}))
#構造線性迴歸模型 驗證 是否學習到數據集的參數
num_point = 1000 //隨機生成1000個點，圍繞在y=0.1*x+0.3的直線周圍
vectors_set = []
for i in range(num_points):
x1 = np.random.normal(0.0, 0.55) //高斯初始化，均值爲0，方差爲0.55
y1 = x1*0.1 + 0.3 +np.random.normal(0.0, 0.03)
vectors_set.append([x1,y1])
x_data = [v[0] for v in vectors_set] //構造樣本點
y_data = [v[1] for v in vectors_set]
plt.scatter(x_data, y_data, c='r')
plt.show()
//構造模型 梯度下降 驗證參數
W=tf.Variable(tf.random_uniform([1],-1.0,1.0), name='W') //構造一維矩陣，取值從-1.0到1.0
b=tf.Variable(tf.zeros([1],name='b')
y = W*x_data + b
loss =tf.reduce_mean(tf.square(y-y_data), name='loss') //預估值和實際值之間的均方誤差作爲損失函數
optimizer = tf.train.GradientDescentOptimizer(0.5) //使用梯度下降方法來優化參數
train = optimizer.minimize(loss, name='train')
sess = tf.Session()
init = tf.global_variables_initializer()
sess.run(init)
print("W=",sess.run(W), "b=",sess.run(b), "loss=", sess.run(loss))
for step in range(20):
sess.run(train)
print("W=",sess.run(W), "b=",sess.run(b), "loss=",sess.run(loss))
#tensorflow構造邏輯迴歸模型
x=tf.placeholder("float", [None, 784])
y=tf.placeholder("float", [None, 10])
W=tf.Variable(tf.zeros([784, 10]))
b=tf.Variable(tf.zeros([10]))
actv = tf.nn.softmax(tf.matmul(x, W) + b)
cost = tf.reduce_mean(-tf.reduce_sum(y*tf.log(actv), reduction_indices=1)) #*y 代表只計算正確分類的損失值
learning_rate = 0.01
optm = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)
pred = tf.equal( tf.argmax(actv, 1), tf.argmax(y,1) )
accr = tf.reduce_mean(tf.cast(pred, "float")) #對了是0，錯了是1
init = tf.global_variables_initializer()
training_epochs = 50 #所有樣本迭代50次
batch_size = 100
display_step =5
sess =tf.Session()
sess.run(init)
for epoch in range(training_epochs):
avg_cost = 0
num_batch = int(mnist.train.num_examples/batch_size)
for i in range(num_batch):
batch_xs, batch_ys = mnist.train.next_batch(batch_size)
sess.run(optm, feed_dict={x:batch_xz, y:batch_ys})
feeds ={x:batch_xs, y:batch_ys}
avg_cost +=sess.run(cost, feed_dict=feeds)/num_batch
#DISPLAY
if epoch % display_step == 0:
feeds_train = {x:batch_xs, y:batch_ys}
feeds_test = {x:mnist.test.images, y:mnist.test.labels}
train_acc = sess.run(accr, feed_dict=feeds_train)
test_acc = sess.run(accr, feed_dict=feeds_test)
#註釋部分：
sess = tf.InteractiveSession()
arr = np.array([[],[],[]])
tf.rank(arr).eval() #查看數組arr 的維度
tf.shape(arr).eval()
tf.argmax(arr, 0).eval() #求最大值的索引（按列/行尋找最大索引）
一個TensorFlow程序通常可以分成兩部分：
第一部分用來構建一個計算圖
第二部分來執行這個圖
w = tf.constant(3)
x = w+2
y = x+5
z = x*3
with tf.Session() as sess:
print(y.eval())
print(z.eval())
在圖的每次執行期間，所有節點值都會被丟棄，但是變量的值不會。
變量的生命週期從初始化器的執行開始，到關閉會話才結束
TensorFlow中的線性迴歸
tensorflow 中的操作 可以接受任意數量的輸入，也可以產生任意數量的輸出。
輸入和輸出都是多維數組，叫作張量。
首先，獲取數據，對所有訓練實例添加一個額外的偏移（x0=1）。接下來，創建兩個TensorFlow的常量節點，x和y以及目標，代碼中還使用了TensorFlow提供的矩陣操作來定義theta。這些矩陣相關函數transpose(),matmul()和matrix_inverse()都是自解釋的。
import numpy as np
from sklearn.datasets import fetch_california_housing
housing = fetch_california_housing()
m,n = housing.data.shape
housing_data_plus_bias = np.c_[np.ones((m,1)), housing.data]
X= tf.constant(housing_data_plus_bias, dtype=tf.float32, name="X")
y= tf.constant(housing.target.reshape(-1,1),dtype=tf.float32,name="y")
XT=tf.transpose()
theta = tf.matmul(tf.matmul(tf.matrix_inverse(tf.matmul(XT,X)),XT),y)
with tf.Session() as sess:
theta_value = theta.eval()
①實現普通神經網絡
#神經網絡
n_hidden_1 = 256
n_hidden_2 = 128
n_input = 784
n_classes = 10
x = tf.placeholder("float",[None,n_input])
y = tf.placeholder("float",[None,n_classes])
stddev = 0.1
weights = {
'w1':tf.Variable(tf.random_normal([n_input, n_hidden_1],stddev=stddev)),
'w2':tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2],stddev=stddev)),
'out':tf.Variable(tf.random_normal([n_hidden_2,n_classes],stddev=stddev)),
}
biases = {
'b1':tf.Variable(tf.random_normal([n_hidden_1])),
'b2':tf.Variable(tf.random_normal([n_hidden_2])),
'out':tf.Variable(tf.random_normal[n_classes])
}
print("NETWORK READY")
#前向傳播函數
def multilayer_perceptron(_X, _weights, _biases):
layer_1 = tf.nn.sigmod(tf.add(tf.matual(_X, _weights['w1']), _biases['b1']))
layer_2 = tf.nn.sigmod(tf.add(tf.matual(layer_1,_weights['w2']), _biases['b2']))
return (tf.matual(layer_2, _weights['out']) + _biases)
#主函數
pred = multilayer_perceptron(x, weights, biases)
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred,y))
optm = tf.train.GradientDescentOptimizer(learning_rate=0.001).minimize(cost)
corr = tf.equal(tf.argmax(pred,1), tf.argmax(y,1))
accr = tf.reduce_mean(tf.cast(corr,"float"))
init = tf.global_variables_initializer()
print("FUNCTIONS READY")
training_epochs = 20
batch_size = 100
display_step = 4
sess = tf.Session()
sess.run(init)
for epoch in range(training_epochs):
avg_cost = 0
total_batch = int(mnist.train.num_examples/batch_size)
for i in range(total_batch):
batch_xs, batch_ys = mnist.train.next_batch(batch_size)
feeds = {x:batch_xs, y:batch_ys}
sess.run(optm, feed_dict=feeds)
avg_cost += sess.run(cost, feed_dict=feeds)
avg_cost = avg_cost / total_batch
#DISPLAY
if(epoch+1) % display_step == 0:
print(epoch,training_epochs,avg_cost)
#打印訓練集的準確度
feeds = {x:batch_xs, y:batch_ys}
train_acc = sess.run(accr, feed_dict=feeds)
print("TRAIN ACCURACY:%.3f"%(train_acc))
#打印測試集的準確度
feeds = {x:mnist.test.images, y:mnist.test.labels}
test_acc = sess.run(accr, feed_dice=feeds)
print("TEST ACCURACY:%.3f"%(test_acc))
print("OPTIMIZATION FINISHED")
②實現卷積神經網絡
n_input=784
n_output=10
weights = { 'wc1':tf.Variable(tf.random_normal([3,3,1,64], stddev=0.1)),
'wc2':tf.Variable(tf.random_normal([3,3,64,128], stddev=0.1)),
'wd1':tf.Variable(tf.random_normal([7*7*128,1024], stddev=0.1)),
'wd2'tf.Variable(tf.random_normal([1024, n_output], stddev=0.1))
}
biases = {'bc1':tf.Variable(,tf.random_normal([64], stddev=0.1)),
'bc2':tf.Variable(,tf.random_normal([128], stddev=0.1)),
'bd1':tf.Variable(,tf.random_normal([1024], stddev=0.1)),
'bd2':tf.Variable(,tf.random_normal([n_output], stddev=0.1))
}
def conv_basic(_input, _w, _b, _keepratio):
_input_r = tf.reshape(_input, shape=[-1, 28, 28 ,1]) #n, h, w, c
#第一個卷積池化層
_conv1 = tf.nn.conv2d(_input_r, _w['wc1'], strides=[1,1,1,1], padding='SAME')
_conv1 =tf.nn.relu( tf.nn.bias_a,dd(_conv1, _b['bc1']) )
_pool1 =tf.nn.max_pool(_conv1, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME')
_pool_dr1 = tf.nn.dropout(_pool1, _keepratio) #隨機殺死一些節點
#第2個卷積池化層
_conv2 = tf.nn.conv2d(_pool_dr1, _w['wc2'], strides=[1,1,1,1], padding='SAME')
_conv2 =tf.nn.relu( tf.nn.bias_a,dd(_conv2, _b['bc2']) )
_pool2 =tf.nn.max_pool(_conv2, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME')
_pool_dr2 = tf.nn.dropout(_pool2, _keepratio) #隨機殺死一些節點
#全連接層
_dense1 = tf.reshape(_pool_dr2, [-1, _w['wd1'].get_shape().as_list()[0]])
_fc1 = tf.nn.relu(tf.add(tf.matmul(_dense1, _w['wd1']), _b['bd1']))
_fc_dr1 = tf.nn.dropout(_fc1, _keepratio)
_out = tf.add(tf.matmul(_fc_dr1, _w['wd2']), _b['bd2'])
x=tf.placeholder(tf.float32, [None, n_input])
y=tf.placeholder(tf.float32, [None, n_output])
keepratio = tf.placeholder(tf.float32)
_pred = conv_basic(x, weights, biases, keepratio)['out']
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(_pred, y))
_corr = tf.equal(tf.argmax(_pred,1), tf.argmax(y,1))
accr = tf.reduce_mean(tf.cast(_corr, tf.float32))
init = tf.global_variables_initializer()
print("GRAPH READY")
sess = tf.Session()
sess.run(init)
training_epochs = 15
batch_size = 16
diaplay_step = 1
for epoch in range(training_epochs):
avg_cost=0
total_batch=10
for i in range(total_batch):
batch_xs, batch_ys = mnist.train.next_batch(batch_size)
sess.run(optm, feed_dict={x:batch_xs, y:batch_ys, keepratio:0.7})
avg_cost += sess.run(cost, feed_dict={x:batch_xs, y:batch_ys, keepratio:1.})/total_batch
if epoch%display_step == 0:
print(" "%(epoch, training_epochs, avg_cost))
train_acc = sess.run(accr, feed_dict={x:batch_ys, y:batch_ys, keepratio:1.})
print("Training accuracy:%.3f" %(train_acc))
#查看函數
print(help(tf.nn.conv2d))