基本概念

基于TensorFlow的神經網絡：用張量表示數據，用計算圖搭建神經網絡，用會話執(zhí)行計算圖，優(yōu)化線上的權重（參數），得到模型。

張量(tensor)：多維數組（列表）

階：張量的維數

  維數      階           名字             例子

  0-D       0        標量 scalar        s=123

  1-D       1        向量 vector        v=[1,2,3]

  2-D       2        矩陣 matrix        m=[[1,2,3],[4,5,6],[7,8,9]]

  n-D       3        張量 tensor        t=[[[.........n個

張量可以表示0階到n階數組（列表）

數據類型：tf.float32 tf.int32 …

張量加法：

import tensorflow as tf

a = tf.constant([1.0 , 2.0])    #constant()代表定義常數
b = tf.constant([3.0 , 4.0])

result = a   b
print(result)

#結果顯示：

            Tensor("add:0", shape=(2,), dtype=float32
                    |   |     |    |          |
               節(jié)點名  第0個  維    一維    數據類型
                      輸出   度    數組
                                  長度2

計算圖只描述了運算過程，不計算運算結果

計算圖（Graph）:搭建神經網絡的計算過程，只搭建，不運算。

會話（Senssion）：執(zhí)行計算圖中的節(jié)點運算。

with tf.Session() as sess:
    print((y))

TensorFlow不會自動生成默認的會話，需要手動指定
當默認的會話被指定之后可以通過tf.Tensor.eval函數來計算一個張量的取值

node1 = tf.constant(3.0, tf.float32, name="node1")
node2 = tf.constant(4.0, tf.float32, name="node2")
result = tf.add(node1, node2)

sess = tf.Session()
with sess.as_default():
    print(result.eval())

參數：即神經元線上的權重W，用變量表示，隨機給初值。

w = tf.Variable(tf.random_normal([2,3] , stddev=2 , mean=0 , seed=1))    #tf.Variable() 生成隨機數
                        |          |         |         |        |
                     正態(tài)分布  產生2*3矩陣  標準差為2  均值為0  隨機種子

tf.truncated_normal()  #去掉過大偏離點的正態(tài)分布
tf.random_uniform()  #平均分布

tf.zeros #全0數組          
tf.zeros([3,2] , int32) #生成[[0,0],[0,0],[0,0]]

tf.ones #全1數組          
tf.ones([3,2] , int32) #生成[[1,1],[1,1],[1,1]]

tf.fill #全定值數組         
tf.fill([3,2] , 6) #生成[[6,6],[6,6],[6,6]]

tf.constant #直接給值    
tf.constant([3,2,1]) #生成[3,2,1]

神經網絡的實現(xiàn)過程：

1、準備數據集，提取特征，作為輸入喂給神經網絡

2、搭建NN結構，從輸入到輸出（先搭建計算圖，再用會話執(zhí)行）

（NN前向傳播算法 --> 計算輸出）

3、大量特征數據喂給NN，迭代優(yōu)化NN參數

（NN反向傳播算法 --> 優(yōu)化參數訓練模型）

4、使用訓練好的模型預測和分類

一、前向傳播 --> 搭建模型，實現(xiàn)推理（以全連接網絡為例）

eg. 生產一批零件將體積X1和重量X2為特征輸入NN，通過NN后輸出一個數值。

變量初始化、計算圖節(jié)點運算都要用會話（with結構）實現(xiàn)：

with tf.Session() as sess:
    ()

變量初始化：在函數中用tf.global_variables_initializer()

init_op = tf.global_variabes_initializer()  #對所有變量初始化（賦初值）
    (init_op)

計算圖節(jié)點運算：在函數中寫入待運算的節(jié)點

(y)

用tf.placeholder占位，在函數中用feed_dict喂數據

喂一組數據：

x = tf.placeholder(tf.float32 , shape=(1,2))  #2代表 有兩個特征 比如零件有質量和體積兩個特征
(y , feed_dict={x : [[0.5,0.6]]})

喂多組數據：

x = tf.placeholder(tf.float32 , shape=(None,2))
(y , feed_dict={x : [[0.1,0.2],[0.2,0.3],[0.3,0.4],[0.4,0.5]]})

二、反向傳播 --> 訓練模型參數，在所有參數上用梯度下降，使NN模型在訓練數據上的損失函數最小

損失函數（loss）：預測值（y）與已知答案（y_）的差距

均方誤差MSE：

loss = tf.reduce_mean(tf.square(y_-y))

反向傳播訓練方法：以減小loss值為優(yōu)化目標

train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)  #梯度下降

train_step = tf.train.MomentumOptimize(learning_rate).minimize(loss) #Momentum優(yōu)化器

train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss) #Adam優(yōu)化器

學習率：決定參數每次更新的幅度

搭建神經網絡：準備、前傳、后傳、迭代

0 準備

import

常量定義

生成數據集

1 前向傳播：定義輸入、參數、刷出

x=

y_=

w1=

w2=

a=

y=

2 反向傳播：定義損失函數、反向傳播方法

loss=

train_step=

3 生成會話，訓練STEPS輪

with tf.session() as sess:
    init_op = tf.global_variables_initallzer()
    sess_run(init_op)

    STEPS=3000
    for i in range(STEPS):
        start=
        end=
        (train_step, feed_dict:)

eg:

#coding：utf-8

import tensorflow as tf

import numpy as np

BATCH_SIZE = 8  #一次喂入神經網絡多少組數據

seed = 23455  #

#基于seed產生隨機數

rng = np.random.RandomState(seed)

#隨機數返回32行2列的矩陣 表示32組 體積和體重 作為輸入數據集

X = rng.rand(32,2)

#從X這個32行2列的矩陣中 取出一行 判斷如果和小于1 就給Y賦值1  如果和不小于1  則給Y賦值0     

#Y作為輸入數據集的標簽（正確答案）  人為給出零件的合格與否 1合格  0不合格

Y = [[int(x0   x1 < 1)] for (x0,x1) in X]

#上面一行代碼類似于下面

#for (x0,x1) in X:
#    if x0 x1<1:
#        Y=1
#    else:
#        Y=0

print("X:\n",X)
print("Y:\n",Y)

#1定義神經網絡的輸入、參數、輸出，定義前向傳播過程

x = tf.placeholder(tf.float32, shape=(None, 2))  #輸入有 體積 重量 兩個特征  數據組數不定
y_ = tf.placeholder(tf.float32, shape=(None, 1))  #標準答案  每個標簽一個元素
w1 = tf.Variable(tf.random_normal([2,3], stddev=1, seed=1))  #[2,3]中 2對應x  3表示隱藏層用3個神經元 
w2 = tf.Variable(tf.random_normal([3,1], stddev=1, seed=1))  #[3,1]中 1對應y  3表示隱藏層用3個神經元

#前向傳播過程描述
a = tf.matmul(x, w1)
y = tf.matmul(a, w2)

#2定義損失函數及反向傳播方法。
loss = tf.reduce_mean(tf.square(y-y_)) #均方誤差
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)  #梯度下降  學習率0.001
#train_step = tf.train.MomentumOptimize(0.001，0.9).minimize(loss) #Momentum優(yōu)化器
#train_step = tf.train.AdamOptimizer(0.001).minimize(loss) #Adam優(yōu)化器

#3生成會話，訓練STEPS輪
with tf.Session() as sess:
    init_op = tf.global_variables_initializer() #變量初始化
    (init_op)

    #輸出目前（未經訓練）的參數取值
    print("w1:\n",(w1))
    print("w2:\n",(w2))
    print("\n")

    #訓練模型
    STEPS = 3000 #訓練3000輪
    for i in range(STEPS):
        start = (i*BATCH_SIZE) % 32
        end = start   BATCH_SIZE
        (train_step, feed_dict={x: X[start:end], y_: Y[start:end]})

        if i % 500 == 0:
            total_loss = (loss, feed_dict={x: X, y_: Y})
            print("After %d training step(s),loss on all data is %g" % (i, total_loss))

    #輸出訓練后的參數取值 
    print("\n")
    print("w1:\n",(w1))
    print("w2:\n",(w2))