Tensorflow筆記_人工智能基礎知識

時間  2019-11-11
標籤 tensorflow 筆記 人工智能 基礎 知識 简体版
原文   原文鏈接
一：本篇的主要內容

1：人工智能的基礎及其含義python

2：神經網絡基礎算法

3：神經網絡八股ubuntu

二：人工智能基礎及其含義

1：人工智能：機器模擬人的意思跟思惟vim

2：機器學習：實現人工智能的一種方法，是人工智能的子集數組

3：深度學習：是深層次的神經網絡，是機器學習的一種實現的方法，是機器學習的子集bash

4：機器學習的定義：若是一個程序能夠在人物T上，隨着經驗E的增長，效果P隨之增長，這個程序能夠從經驗中學習網絡

5：機器學習的過程/單個神經元dom

 

三：基於Tensorflowde NN

1：用 張量 表示數據機器學習

2：用 計算圖 搭建神經網絡函數

3：用 會話 執行計算圖

# 1 張量( tensor )

  • 多維數組（列表），用"階"表示張量的維數，張量能夠表示0階到N階數組
  • 判斷張量是幾階的：經過張量遊標的方括號數，0個就是0階，n個就是n階
維數 階 名字 例子
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]]
n-D n 張量 tensor t =[[[....]]]

 

# 2 計算圖

  • 搭建神經網絡的計算過程，只搭建，不運算
  • 計算圖只描述運算過程，不計算運算的結果 
  • tf.constant 定義常數
  • 在tensorflow中的數據的類型有 浮點型：tf.float32  整形：tf.int32 
  • tf.int8        # 8位整數
tf.int16：    # 16位整數
tf.int32：    # 32位整數
tf.int64：    # 64位整數

tf.uint8    # 8位無符號整數
tf.uint16    # 16位無符號整數

tf.float16    # 16位浮點數
tf.float32    # 32位浮點數
tf.float64    # 64位浮點數
tf.double    # 等同於tf.float64

tf.string    #字符串

tf.bool        #布爾型

tf.complex64    # 64位複數
tf.complex128    # 128位複數

# 實現Tensorflow

# vim中編輯
import tensorflow as tf
a = tf.constant([1.0,2.0])  # 定義一個張量a的值爲常數1.0  2.0  
b = tf.constant([3.0,4.0])  # 定義一個張量b的值爲常數3.0  4.0
result = a + b
print result         

# 在終端中輸出結果
python tf3_1.py

# 輸出的結果爲（顯示的結果爲一個張量，但沒有輸出運算結果）
Tensor("add:0", shape=(2,), dtype=float32)
# add:節點名  0:第0個輸出  shape:維度  2:一維數組的長度爲2  dtype=float32數據類型爲浮點型

# 搭建計算圖

 

 

 

 

 

 

 

 

x1,x2表示輸入，w1,w2分別是x1到y和x2到y的權重，y = x1 * w1 + x2 * w2

實現上方的計算圖

import tensorflow as tf
x = tf.constant([[1.0, 2.0]])　　 # 定義一個 2 階張量等於[[1.0,2.0]]
w = tf.constant([[3.0], [4.0]])  # 定義一個 2 階張量等於[[3.0],[4.0]]
y = tf.matmul(x, w)  矩陣乘法
print y
# 輸出顯示的結果表示y是一個張量，只搭建承載計算過程的計算圖，並無運算，可利用Session()來獲得計算結果（看下方會話）

# 3 會話（ Session ）：

會話：執行圖中節點運算

    import tensorflow as tf
    x = tf.constant([[1.0,2.0]])
    w = tf.constant([3.0],[4.0]])
    y = tf.matmul(x,w)　　# y是x和w的矩陣乘法 print y
    with tf.Session() as sess:
         print sess.run(y)　　# sess.run(y) 要執行計算結果 執行y運算 # 執行後的結果 
    # doaoao@ubuntu:~/tf$ python tf3_4.py
    Tensor("MatMul:0", shape=(1, 1), dtype=float32)　　# 表示y是一個張量 [[11.]]   # 執行後的結果
    # 計算過程1.0*3.0 + 2.0*4.0 = 11.0

# 注：修改Tensorflow的配置文件（讓Tensorflow的提示等級下降）

    doaoao@ubuntu:~/tf$ vim ~/.bashrc  #打開其配置文件
    doaoao@ubuntu:~/tf$ source ~/.bashrc  # 讓所修改的配置生效
    # 在配置文件中加入 export TF_CPP_MIN_LOG_LEVEL=2

# 4 參數

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

w = tf.Variable(tf.random_normal([2,3], stddev=2, mean=0, seed=1))
# 生成隨機數 將生成的方式寫在括號中 
# 後三個若是沒有特殊要求，能夠不寫
 
# tf.random_normal :表示生成正態分佈的隨機數
# [2,3]            ：產生2*3的矩陣  兩行三列
# stddev=2         ：標準差爲2
# mean=0           ：均值爲0
# seed=1           : 隨機種子（若是將隨機種子去掉，每次生成的隨機數將不一致）

# tf.truncated_normal
# 生成去掉過大偏離點的正態分佈
# 若是隨機出來的數，偏離平均值超過兩個標準差，這個數據將從新生成

# 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]

 # 5 神經網絡的實現過程（前三個步驟爲訓練過程，第四步爲使用過程）

  1. 準備數據集，提取特徵，做爲輸入餵給神經網絡
    1. 包括數據集的特徵，包括數據集的標籤（如零件是否合格）
  2.  搭建NN結構，從輸入到輸出（先搭建計算圖，在用會話執行）
    1. ( NN前向傳播法 -> 計算輸出 ）
  3.  大量特徵數據爲給NN，迭代優化參數
    1. ( NN 反向傳播法 -> 優化參數訓練模型 )
    2. 將大量數據餵給神經網絡，獲得大量輸出，將每次輸出與標準答案的差傳給神經網絡，知道模型達到要求
  4. 使用訓練好的模型訓練和分類

# 6 前向傳播（搭建模型，實現推理）

前向傳播就是搭建模型的計算過程，讓模型具備推理能力，能夠針對一組輸入給出相應的輸出

例如：生產一批零部件，將體積爲x，重量爲y的特徵輸入NN，當體積和總量經過NN後輸出一個數值

由搭建的神經網絡可得，隱藏層節點 a11 = x1* w11+x2*w21=0.14+0.15=0.29，也可算得節點 a12 = 0.32，a13 = 0.38，最終計算獲得輸出層 Y = -0.015，這便實現了 前向傳播過程

# 第一層

1：用x表示輸入，是一個一行兩列的矩陣，表示一次輸入一組特徵，這組特徵包含了體積和重量兩個元素

2：W 前節點編號，後節點編號 (層數)  爲待優化參數，第一層的w前面有兩個節點（x1,x2），後面有三個節點（a11,a22,a13），w是個兩行三列的矩陣，能夠表示爲

3：神經網絡共有幾層（或當前屬於第幾層）都是指的是計算層，輸入層不算是計算層，因此a爲第一層網絡，a是一個一行三列的矩陣

# 第二層

1：第二層w前面有三個節點，後面有一個節點，因此W(2)是一個三行一列的矩陣，可表示爲以下

1：變量的初始化，計算圖節點運算都要用會話（wish結構）實現

wish tf.Session() as sess:
    sess.run()

2：變量的初始化：在sess.run函數中用 tf.global_varlables_initiallzer() 彙總全部的變量

init_op = tf.global_varlables_initiallzer()
sess.run(init_op)

3：計算圖節點運算：在sess.run函數中，寫入待運算的節點

sess.run(y)

4：先用tf.placeholder 幫輸入佔位，在sess.run 函數中用feed_dict 喂數據

# 喂一組數據
# 1表示喂入一組數據  2表示喂入數據的特徵有幾個（好比重量體積有兩個特徵）
x = tf.placeholder(tf.float,shape=(1,2)) 
sess.run(y,feed_dict={x: [[0.5,0.6]]})

# 一次性喂多組數據
# None 表示先空着
x = tf.placeholder(tf.float,shape=(None,2))
sess.run(y,feed_dict={x: [[0.1,0.2],[0.3,0.4]]})

# 向神經網絡中國寫入特定的值

#coding:utf-8
import tensorflow as tf

# 定義輸入和參數
x = tf.constant([[0.7,0.5]])　　# 定義體積和參數
w1 = tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))　　# 2行3列的正態分佈隨機數矩陣，標準差爲1，隨機種子爲1
w2 = tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))　　

# 定義前向傳播的過程
a = tf.matmul(x,w1)　　# x與w1的矩陣乘法
y = tf.matmul(a,w2)　　# a與w2的矩陣乘法

# 用會話計算結果
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()　　# 將初始化全部變量的函數簡寫爲 init_op
    sess.run(init_op)
    print "y in tf3_5.py is :\n",sess.run(y)

# 向神經網絡中喂入一組數據（特徵）

#coding:utf-8
import tensorflow as tf

# 定義輸入和參數
# 用placeholder實現輸入定義（喂入一組特徵 shape中的第一個參數爲1）
x = tf.placeholder(tf.float32,shape=(1,2))
w1 = tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))
w2 = tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))

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

# 用會話計算結果
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    print "y in tf3_5.py is :\n",sess.run(y,feed_dict={x: [[0.7,0.5]]})

# 向神經網絡喂入多組數據（特徵）

#coding:utf-8
import tensorflow as tf

# 定義輸入和參數
# 利用placeholder 定義輸入 (sess.run 喂入多組數據)（由於不知道喂入多少組，因此shape中的第一個參數爲None）
x = tf.placeholder(tf.float32,shape=(None,2))
w1 = tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))
w2 = tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))

#定義向前傳播的過程
a = tf.matmul(x,w1)
y = tf.matmul(a,w2)

# 調用會話計算結果
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
　　 # 第一組喂體積0.7重量0.5，第二組喂體積0.2重量0.3.... print "y in tf3_5.py is :\n",sess.run(y,feed_dict={x: [[0.7,0.5],[0.2,0.3],[0.3,0.4],[0.4,0.5]]})
    print "w1:\n", sess.run(w1)　　# 能夠查看隨機生成的w1 print "w2:\n", sess.run(w2)　　# 能夠查看隨機生成的w2

# 7 反向傳播

1：反向傳播：訓練模型參數，在全部的參數上用梯度降低，使NN模型在訓練的數據上的損失函數最小

2：反向傳播的訓練方法：以減少loss值爲優化的目標

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

4：均方偏差MSE：求向前傳播計算結果與已知答案之差的平方再求平均

　  

　　用tensorflow函數表示爲：loss = tf.reduce_mean(tf.square(y_-y))  //已知答案減去前向傳播計算出來的結果

5：反向傳播的訓練方法：以減少loss值爲優化目標（訓練時選擇下方其中一個便可）

# 梯度降低
strain_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(losss)

# Momenttum優化器
strain_step = train.MomenttumOptimizer(learning_rate,momentum).minimize(loss)
# Adam優化器
strain_stept = tf.train.AdamOptimizer(learning_rate).minimize(lose)


# 三種優化器的區別
1：梯度降低法，使用梯度降低法，使參數沿着梯度的反方向，即總損失減少的方向移動，實現更新參數
2：monenttum優化器，在更新參數時，利用了超參數
3：Adam優化器，利用自適應學習率的優化算法，Adam算法和隨機梯度降低算法不一樣。
　　隨機梯度降低算法保持單一的學習率更新全部的參數，學習率在訓練過程當中並不會改變。
　　而 Adam 算法經過計算梯度的一階矩估計和二 階矩估計而爲不一樣的參數設計獨立的自適應性學習率。

# 上方的優化器都須要一個稱爲學習率的參數 learning_rate

6：學習率 learning_rate ：決定參每次的更新幅度，使用時能夠選擇一個比較小的值填入神經網絡的實現過程

　　（學習率過大：震盪不收斂狀況      學習率太小：會出現收斂速度慢狀況）

7：神經網絡的實現過程

　　7.1：準備數據集，提取特徵，做爲輸入餵給神經網絡

　　7.2：搭建神經網絡結構，從輸入到輸出（先搭建計算圖，在用會話執行）（神經網絡前向傳播算法->計算輸出　　

　　7.3：大量的數據特徵餵給神經網絡，迭代優化神經網絡參數（神經網絡反向傳播->優化訓練模型）

　　7.4：使用訓練號的模型進行預測和分類

 四：搭建神經網絡的八股：準備工做，前向傳播，反向傳播，循環迭代

1：準備

　　# import相關模塊    　　# 常量的定義   　　# 生成數據集

2：前向傳播：定義輸入    定義輸出    

　　Y = （數據集的標籤）

　　x =（輸入參數）

　　y_ = （標準答案）  

　　w1 = （第一層網絡的參數）  

　　w2 = （第二層網絡的參數）

　　a =  （先用矩陣乘法求出 a）

　　y = （定義推理過程 用矩陣乘法求出 y）  

3：反向傳播：定義損失函數，反向傳播的方法  

　　loss=  （定義損失函數）  

train_step= （反向傳播方法）

 

4：生成會話 訓練STEPS輪

　　在with中完成迭代

# coding:utf-8
# 導入模塊 生成模擬的數據集
import tensorflow as tf
  
# 導入numpy模塊 python的科學計算模塊
import numpy as np

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

seed = 23455

# 基於seed產生的隨機數
rng = np.random.RandomState(seed)
# 隨機數返回32行2列的矩陣　表示具備32組　具備兩種特徵（體積　重量）
# 做爲輸入的數據集
X = rng.rand(32,2)

# 從這個32行２列的矩陣中　取出一行　判斷若是小於１　給Ｙ賦值1 不然給Y賦值０
# Y 做爲輸入數據集的標籤（輸入數據集的正確答案）  體積 + 重量 < 1爲合格（由於沒有數據，因此這樣標記）
Y = [[int(x0 + x1 < 1)] for (x0, x1) in X]
print "X:\n",X
print "Y:\n",Y

# 定義神經網絡的 輸入　參數　輸出　定義向前傳播的過程
x = tf.placeholder(tf.float32, shape=(None, 2))

# 正確答案的標籤（每一個標籤只有一個元素 合格或者不合格）
y_ = tf.placeholder(tf.float32, shape=(None, 1))
 
# w1（兩行三列） 對應x  w2（三行一列） 對應y
w1 = tf.Variable(tf.random_normal([2, 3],stddev=1, seed=1))
w2 = tf.Variable(tf.random_normal([3, 1],stddev=1, seed=1))
# 前向傳播的計算過程描述 用矩陣乘法實現
a = tf.matmul(x, w1)
y = tf.matmul(a, w2)

# 定義損失函數loss 及反向傳播方法
# 使用均方偏差計算loss
loss = tf.reduce_mean(tf.square(y-y_))

# 將其學習率設置爲0.001　　(下方使用的爲梯度降低)
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)
  
# 生成回話 訓練STEPS輪
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)

    # 打印優化前的參數 w1 w2
    print "w1:\n",sess.run(w1)
    print "w2:\n",sess.run(w2)
    print "\n"

    # 訓練模型
    STEPS = 3000
    for i in range(STEPS):
        start = (i*BATCH_SIZE) % 32
        end = start + BATCH_SIZE

        # 抽取相應的數據集 從start 到 end 的特徵和標籤，喂入神經網絡
        sess.run(train_step, feed_dict={x: X[start:end],y_: Y[start:end]})
        if i % 500 == 0:
            total_loss = sess.run(loss, feed_dict={x:X,y_:Y})
            print ("After %d,%g" % ( i,total_loss))

    # 輸出訓練後的參數值
    print "\n"
    print "w1:\n",sess.run(w1)
    print "w2:\n",sess.run(w2)

 ...

 ...

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程