1，感謝莫煩

2，第一個實例：用tf擬合線性函數

import tensorflow as tf
import numpy as np

# create data
x_data = np.random.rand(100).astype(np.float32)
y_data = x_data*0.1 + 0.3    #先創建我們的線性函數目標

#搭建模型
Weights = tf.Variable(tf.random_uniform([1], -1.0, 1.0))
biases = tf.Variable(tf.zeros([1]))
y = Weights*x_data + biases

#計算誤差，然後根據誤差調節loss
 

loss = tf.reduce_mean(tf.square(y-y_data))
optimizer = tf.train.GradientDescentOptimizer(0.5)
train = optimizer.minimize(loss)    #我們的目標是讓誤差盡量小

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

sess = tf.Session()    #創建會話，
sess.run(init)          # 開始運行。tf需要在會話裏運行，原因不明

for step in range(201):
    sess.run(train)
    
 
if step % 20 == 0:    #每訓練一段時間打印一下結果
        print(step, sess.run(Weights), sess.run(biases))

3,會話控制session

import tensorflow as tf

# create two matrixes

matrix1 = tf.constant([[3,3]])    #tf.constant表示常量
matrix2 = tf.constant([[2],
                       [2]])
product = tf.matmul(matrix1,matrix2)    #
 
兩個同類型是數相乘，不同於tf.multiply(),這只是表示運算的步驟，而不是過程

#要想運行兩個數相乘得到結果，有以下兩種方法
# method 1
sess = tf.Session()
result = sess.run(product)
print(result)
sess.close()


# method 2
with tf.Session() as sess:
    result2 = sess.run(product)
    print(result2)

4，變量Variable

和python不一樣的是，tf中只有定義了是變量的才是變量，這一點和一直以來的習慣不一樣

語法：

import tensorflow as tf

state = tf.Variable(0, name=‘counter‘)

# 定義常量 one
one = tf.constant(1)

# 定義加法步驟 (註: 此步並沒有直接計算)
new_value = tf.add(state, one)

# 將 State 更新成 new_value
update = tf.assign(state, new_value)

#但是以上步驟沒有一步是直接運算的，要運算還需要載入變量
init = tf.global_variables_initializer()    #激活變量是這樣滴

#激活以後還是需要放在會話中運行
with tf.Session() as sess:
    sess.run(init)
    for _ in range(3):
        sess.run(update)
        print(sess.run(state))

5，placeholder傳入值

import tensorflow as tf

#在 Tensorflow 中需要定義 placeholder 的 type ，一般為 float32 形式
input1 = tf.placeholder(tf.float32)
input2 = tf.placeholder(tf.float32)

# mul = multiply 是將input1和input2 做乘法運算，並輸出為 output 
ouput = tf.multiply(input1, input2)

with tf.Session() as sess:
    print(sess.run(ouput, feed_dict={input1: [7.], input2: [2.]}))

#placeholder到底像raw_input 呢還是argv呢

6，掰彎利器激勵函數

7，添加層

#!coding=utf-8
import tensorflow as tf
import numpy as np

def add_layer(inputs, in_size, out_size, activation_function=None):  
    Weights = tf.Variable(tf.random_normal([in_size, out_size]))
    biases = tf.Variable(tf.zeros([1, out_size]) + 0.1)    #加0.1是為了不讓它為0
    
    Wx_plus_b = tf.matmul(inputs, Weights) + biases    #最基礎的函數：權重乘以x加上偏移量為y
    #如果激勵函數為none，那我們得到的Wx_plus_b就是結果，如果有激勵函數，那就需要把結果套上一層激勵函數
    if activation_function is None:
        outputs = Wx_plus_b
    else:
        outputs = activation_function(Wx_plus_b)
    return outputs

建造神經網絡：

x_data = np.linspace(-1,1,300, dtype=np.float32)[:, np.newaxis]
noise = np.random.normal(0, 0.05, x_data.shape).astype(np.float32)
y_data = np.square(x_data) - 0.5 + noise    #y=x的平方減去0.5加上幹擾

#np.linspace意思的創建一個從-1到1的一維數組，這個數組裏有300個元素，x_data的數字類型是float32。
#np.newaxis例如：print(np.arange(0, 10)[:, np.newaxis]) 結果將是[[0] [1] [2] [3] [4] [5] [6] [7] [8] [9]]
#noise是故意插入數組中的幹擾數字，省的算出權重和偏移量過快

xs = tf.placeholder(tf.float32, [None, 1])
ys = tf.placeholder(tf.float32, [None, 1])

#定義隱藏層，inputs為xs，大小為一個，經過10個隱藏層，激勵函數為tf.nn.relu
l1 = add_layer(xs, 1, 10, activation_function=tf.nn.relu)

#輸出層，輸出層的輸入值為l1，輸入的值有10個，輸出只有一層，激活函數是沒有的
prediction = add_layer(l1, 10, 1, activation_function=None)

#層雖然定義好了，我們仍舊需要通過訓練優化參數，損失函數為，對二者差的平方求和再取平均。
loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys - prediction),
                     reduction_indices=[1]))

#學習效率就等於
train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss)

init = tf.global_variables_initializer()  # 對變量進行初始化，然後會話中開始跑
sess = tf.Session()
sess.run(init)

#開始訓練

for i in range(1000):
    # 註意當運算要用到placeholder時，就需要feed_dict這個字典來指定輸入
    sess.run(train_step, feed_dict={xs: x_data, ys: y_data})
    if i % 50 == 0:
        # to see the step improvement
        print(sess.run(loss, feed_dict={xs: x_data, ys: y_data}))
    

訓練得到的結果是loss損失的大小，損失越來越小，越來越接近實際值：

8，結果可視化

可視化需要用到的依賴包是：matplotlib，目測豆瓣和清華的鏡像沒法用，不知原因，直接按照教程來一遍吧。

實例：

#!coding=utf-8
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

def add_layer(inputs, in_size, out_size, activation_function=None):  
    Weights = tf.Variable(tf.random_normal([in_size, out_size]))
    biases = tf.Variable(tf.zeros([1, out_size]) + 0.1)    #加0.1是為了不讓它為0
    
    Wx_plus_b = tf.matmul(inputs, Weights) + biases    #最基礎的函數：權重乘以x加上偏移量為y
    #如果激勵函數為none，那我們得到的Wx_plus_b就是結果，如果有激勵函數，那就需要把結果套上一層激勵函數
    if activation_function is None:
        outputs = Wx_plus_b
    else:
        outputs = activation_function(Wx_plus_b)
    return outputs
    
x_data = np.linspace(-1,1,300, dtype=np.float32)[:, np.newaxis]
noise = np.random.normal(0, 0.05, x_data.shape).astype(np.float32)
y_data = np.square(x_data) - 0.5 + noise    #y=x的平方減去0.5加上幹擾

#np.linspace意思的創建一個從-1到1的一維數組，這個數組裏有300個元素，x_data的數字類型是float32。
#np.newaxis例如：print(np.arange(0, 10)[:, np.newaxis]) 結果將是[[0] [1] [2] [3] [4] [5] [6] [7] [8] [9]]
#noise是故意插入數組中的幹擾數字，省的算出權重和偏移量過快
xs = tf.placeholder(tf.float32, [None, 1])
ys = tf.placeholder(tf.float32, [None, 1])


#定義隱藏層，inputs為xs，大小為一個，經過10個隱藏層，激勵函數為tf.nn.relu
l1 = add_layer(xs, 1, 10, activation_function=tf.nn.relu)

#輸出層，輸出層的輸入值為l1，輸入的值有10個，輸出只有一層，激活函數是沒有的
prediction = add_layer(l1, 10, 1, activation_function=None)

#層雖然定義好了，我們仍舊需要通過訓練優化參數，損失函數為，對二者差的平方求和再取平均。
loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys - prediction),
                     reduction_indices=[1]))

#學習效率就等於
train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss)

init = tf.global_variables_initializer()  # 對變量進行初始化，然後會話中開始跑
sess = tf.Session()
sess.run(init)

#開始訓練

fig=plt.figure()    #先生成一個圖片框，畫板類似的
ax=fig.add_subplot(1,1,1)
#參數 111 的意思是: 顯示一個圖 或者寫成 (1,1,1);參數 349 的意思是：將畫布分割成 3 行 4 列，圖像畫在從左到右從上到下的第 9 塊
ax.scatter(x_data,y_data)
plt.show()

就目前而言，先把x_data ,y_data的取值畫出來，x_data是在-1到1之間取了300個點，y_data是x_data的平方加上噪音，目前是這樣的圖：

fig=plt.figure()    #先 生成一個圖片框，畫板類似的
ax=fig.add_subplot(1,1,1)
#參數 111 的意思是: 顯示一個圖 或者寫成 (1,1,1);參數 349 的意思是：將畫布分割成 3 行 4 列，圖像畫在從左到右從上到下的第 9 塊
ax.scatter(x_data,y_data)
plt.ion()    #為了讓畫板能被不斷更新添加，如果只有一個show（）函數，那就只能畫一次
plt.show()

for i in range(1000):
    # 註意當運算要用到placeholder時，就需要feed_dict這個字典來指定輸入
    sess.run(train_step, feed_dict={xs: x_data, ys: y_data})
    if i % 50 == 0:
        # to see the step improvement
        #print(sess.run(loss, feed_dict={xs: x_data, ys: y_data}))
        try:
            ax.lines.remove(lines[0])    #去掉畫的第一條線,第一次沒有這條線，所以except跳過去了
        except Exception:
            pass
        prediction_value=sess.run(prediction,feed_dict={xs:x_data})
        lines=ax.plot(x_data,prediction_value,‘r‘,lw=5)    #畫一條連續的線，畫完了必須要移除，否則畫不了下一條
        plt.pause(0.1)

雖然不是很懂，但是可以看到訓練的結果確實是不斷擬合原始數據哦。啦啦。至於為什麽不大懂，估計是numpy和matplotlib包以前沒用過的原因。

題外話，激活函數是可以變化的哦， tf.nn.sigmoid(x)， tf.nn.relu(x)，tf.nn.tanh(x)， tf.nn.softplus(x)經過本人實踐證明，同樣的條件下，l1 = add_layer(xs, 1, 10, activation_function=tf.nn.softplus)是擬合最好的。據說它是這個： log(exp( features) + 1)

tensorflow 莫煩教程