前言

本篇將簡要介紹強化學習的“自主學習Flappy Bird”實體
讀完本篇，你將了解：

一、強化學習
1.相關概念
2.馬爾可夫決策程序（MDP）（model base 模型）
3.蒙特卡洛強化學習
4.Q-learning演算法
5.深度強化學習（DRL）
6.Deep Q Network(DQN)

二、自主學習Flappy Bird
1.程式基本框架（觀察期、探索期、訓練期）
2.動作選擇模塊
3.卷積神經網路-CNN
4.Tensorflow&openCV庫

三、關于機器學習專欄的一點總結
1.無監督學習
2.監督學習
3.強化學習，

一、強化學習（增強學習）

1.定義

（1）程式或智能體（agent）通過與環境不斷地進行互動學習一個從環境到動作的映射，學習的目標是使累計回報最大化

（2）是一種試錯學習，因其在各種狀態（環境）下需盡量嘗試所有可以選擇的動作，通過環境給出的反饋（獎勵）來判斷動作的優劣，最侄訓得環境和最優動作的映射關系（策略）

2.舉例：吃豆游戲

（1）基本組件
①agent: 大嘴小怪物
②環境:整個迷宮中的所有資訊
③獎勵:agent每走一步,需要扣除1分,吃掉小球得10分，吃掉敵人得200分,被吃掉游戲結束，
④動作:在每種狀態下,agent能夠采用的動作,比如上下左右移動，
⑤策略:在每種狀態下,采取最優的動作，
⑥學習目標:獲得最優的策略,以使累計獎勵最大(即Score )，

（2）圖示

3.馬爾可夫決策程序（MDP）（model base 模型）

（1）馬爾可夫決策程序(MarkovDecision Process)通常用來描述一個強化學習問題，
（2）智能體agent根據當前對環境的觀察采取動作獲得環境的反饋,并使環境發生改變的回圈程序，

（3）基本元素
①s∈S：有限狀態state集合，s表示某個特定狀態
②a∈A：有限動作action集合，a表示某個特定動作
③T(S,a,S’)~Pr(s’|s,a)：狀態轉移模型，根據當前狀態s和動作a預測下一個狀態s，Pr表示從s采取行動a轉移到s‘的概率
④R(s,a)：表示agent采取某個動作后的即時獎勵，其他表現形式：R(s,a,s’),R(s)
⑤Policy π(s)->a：根據當前state來產生action，可表現為a=π(s)或π(a|s)=P(a|s)，后者表示某種狀態下執行某個動作的概率

（4）值函式
①狀態值函式v表示執行策略π能得到的累計折扣獎勵

整理后得

②狀態動作值函式Q(s,a)表示在狀態s下執行動作a能得到的累計折扣獎勵

整理后得

③最優值函式

（5）最優控制
在得到最優值函式之后，可以通過值函式的值得到狀態s時應該采取的動作a

4.蒙特卡洛強化學習

（1）免模型學習
①在現實的強化學習任務中,環境的轉移概率、獎勵函式往往很難得知,甚至很難得知環境中有多少狀態，
②若學習演算法不再依賴于環境建模,則稱為免模型學習,蒙特卡洛強化學習就是其中的一種，

（2）蒙特卡洛強化學習使用多次采樣,然后求取平均累計獎賞作為期望累計獎賞的近似，
<s0,a0,s1,a1,r2,…,S(T-1),a(T-1),rT,ST>

（3）直接對狀態動作值函式Q(s,a)進行估計,每采樣一條軌跡,就根據軌跡中的所有“狀態-動作”利用下面的公式對來對值函式進行更新，

（4）貪心策略
①每次采樣更新完所有的“狀態-動作”對所對應的Q(s,a)，就需要更新采樣策略n，但由于策略可能是確定性的,即一個狀態對應一個動作,多次采樣可能獲得相同的采樣軌跡，因此需要借助ε貪心策略
②如圖

5.Q-learning演算法

（1）蒙特卡洛強化學習演算法需要采樣一個完整的軌跡來更新值函式,效率較低,此外該演算法沒有充分利用強化學習任務的序貫決策結構，

（2）Q-learning演算法結合了動態規劃與蒙特卡洛方法的思想,使得學習更加高效，

（3）程序
①假設對于狀態動作對(s,a)基于t次采樣估算出其值函式為∶

②在進行t+1次采樣后，依據增量更新得到:

③然后，將,替換成系數α(步長），得到:

④以γ折扣累計獎賞為例∶

⑤則值函式的更新方式如下:

（4）流程

注：請參考周志華老師《機器學習》一書

6.深度強化學習（DRL）

（1）傳統強化學習：真實環境中的狀態數目過多,求解困難，

（2）深度強化學習:將深度學習和強化學習結合在一起,通過深度神經網路直接學習環境(或觀察)與狀態動作值函式Q(s,a)之間的映射關系，簡化問題的求解，

7.Deep Q Network(DQN)

（1）介紹
①是將神經網路(neural network）和Q-learning結合,利用神經網路近似模擬函式Q(s,a)
②輸入是問題的狀態(e.g.,圖形），輸出是每個動作a對應的Q值
③然后依據Q值大小選擇對應狀態執行的動作,以完成控制，

（2）神經網路的引數︰應用監督學習完成

（3）DQN學習程序
①狀態s輸入，獲得所有動作對應的Q值Q(s,a)
②選擇對應Q值最大的動作a’并執行
③執行后環境發生改變，并能夠獲得環境的獎勵r
④利用獎勵r更新Q(s,a’)——強化學習
⑤利用新的Q(s,a’)更新網路引數—監督學習

（4）講解

二、自主學習Flappy Bird游戲專案分析

1.“自主學習Flappy Bird游戲”實體介紹

（1）深度強化學習
①2013年,Deep Mind團隊在NIPS上發表《PlayingAtari with Deep Reinforcement Learning》一文,在該文中首次提出Deep Reinforcement Learning—詞
②并且提出DQN(DeepQ-Network)演算法,實作了從純影像輸入完全通過學習來玩Atari游戲，

（2）Atari游戲
①接下來的學習中,我們將通過python實作的一個開源的自主學習flappy bird游戲的小專案,更細致的講解有關深度強化學習的實體應用，
②Flappy Bird游戲：由來自越南的獨立游戲開發者開發的一款游戲，在游戲中,玩家需要點擊螢屏控制小鳥跳躍,跨越由各種不同長度水管組成的障礙，

③Flappy Bird游戲和Atari游戲的操作方法很相似,同樣可以使用DQN進行學習，

（3）自主學習Flappy Bird游戲
①目標：使用深度強化學習方法自主學習Flappy Bird游戲策略,達到甚至超過人類玩家的水平，
②技術路線：Deep Q-Network
③使用工具：tensorflow + pygame + cv2

2.Flappy Bird自主學習程式基本框架

（1）程式與模擬器互動
①訓練程序也就是神經網路(agent)不斷與游戲模擬器(Environment)進行互動
②通過模擬器獲得狀態，給出動作，改變模擬器中的狀態，獲得反饋，依據反饋更新策略的程序

（2）訓練程序
①觀察期(OBSERVE)：程式與模擬器進行互動，隨機給出動作，獲取模擬器中的狀態，將狀態轉移程序存放在D(Replay Memory)中
②探索期(EXPLORE)：程式與模擬器互動的程序中，依據Replay Memory中存盤的歷史資訊更新網路引數，并隨訓練程序降低隨機探索率ε
③訓練期(TRAIN):ε已經很小,不再發生改變，網路引數隨著訓練程序不斷趨于穩定，

（3）整體框架——觀察期

①打開游戲模擬器，不執行跳躍動作，獲取游戲的初始狀態
②根據ε貪心策略獲得一個動作（由于神經網路引數也是隨機初始化的，在本階段引數也不會進行更新，所以統稱為隨機動作），并根據迭代次數減小ε的大小

③由模擬器執行選擇的動作，能夠回傳新的狀態和反饋獎勵
④將上一狀態s ，動作a，新狀態s ‘，反饋r組裝成( s , a , s’ ，r)放進Replay Memory中用作以后的引數更新
⑤根據新的狀態s '，根據ε貪心策略選擇下一步執行的動作，周而復始，直至迭代次數到達探索期

（4）整體框架——探索期

探索期與觀察期的唯一區別在于會根據抽樣對網路引數進行更新，

①迭代次數達到一定數目，進入探索期，根據當前狀態s，使用ε貪心策略選擇一個動作(可以是隨機動作或者由神經網路選擇動作），并根據迭代次數減小ε的值
②由模擬器執行選擇的動作，能夠回傳新的狀態和反饋獎勵
③將上一狀態s ，動作a，新狀態s’，反饋r組裝成( s , a , s’ ，r)放進Replay Memory中用作引數更新
④從Replay Memory中抽取一定量的樣本，對神經網路的引數進行更新
⑤根據新的狀態s '，根據s貪心策略選擇下一步執行的動作，周而復始，直至迭代次數到達訓練期

（5）整體框架——訓練期

迭代次數達到一定數目，進入訓練期，本階段跟探索期的程序相同，只是在迭代程序中不再修改ε的值

（6）模擬器

①游戲模擬器
1）使用Python的Pygame模塊完成的FlappyBird游戲程式
2）為了配合訓練程序,在原有的游戲程式基礎上進行了修改，
3）參考以下網址查看游戲原始碼:https://github.com/sourabhv/FlapPyBird

②圖示通過模擬器獲取游戲的畫面，
③訓練程序中使用連續4幀影像作為一個狀態s ，用于神經網路的輸入，

（7）動作選擇模塊
①動作選擇模塊︰為s貪心策略的簡單應用，以概率ε隨機從動作空間A中選擇動作，以1-ε概率依靠神經網路的輸出選擇動作:
②如圖

、
③DQN∶用卷積神經網路對游戲畫面進行特征提取，這個步驟可以理解為對狀態的提取，

（8）卷積神經網路-CNN

展示卷積操作
①卷積核∶這里的卷積核指的就是移動中3*3大小的矩陣，
②卷積操作∶使用卷積核與資料進行對應位置的乘積并加和，不斷移動卷積核生成卷積后的特征，

③池化操作∶對卷積的結果進行操作，最常用的是最大池化操作，即從卷積結果中挑出最大值，如選擇一個2*2大小的池化視窗（操作如圖示):

④卷積神經網路：把Image矩陣中的每個元素當做一個神經元,那么卷積核就相當于輸入神經元和輸出神經元之間的鏈接權重,由此構建而成的網路被稱作卷積神經網路，

⑤Flappy Bird-深度神經網路

本實驗中使用的深度神經網路結構就是多個卷積操作和池化操作的累加，

1）對采集的4張原始影像進行預處理，得到80804大小的矩陣;

2）使用32個884大小步長4的卷積核對以上矩陣進行卷積，得到202032大小的矩陣;
注:在tensorflow中使用4維向量表示卷積核[輸入通道數，高度，寬度，輸出通道數]，對應于上面的[4,8,8,32]，可以理解為32個884大小的卷積核;

3）對以上矩陣進行不重疊的池化操作，池化視窗為22大小，步長為2，得到101032大小的矩陣;
4）使用64個4432大小步長為2的卷積核對以上矩陣進行卷積，得到5564的矩陣;
5）使用64個3364大小步長為1的卷積核對以上矩陣進行卷積，得到5564的矩陣;
6）將輸出的5564大小的陣列進行reshape，得到11600大小的矩陣;
7）在之后添加一個全連接層，神經元個數為512;
8）最后一層也是一個全連接層，神經元個數為2，對應的是就是兩個動作的動作值函式;

⑥通過獲得輸入s，神經網路就能夠:
1）輸出Q(s,a1)和Q(s,a2)比較兩個值的大小，就能夠評判采用動作a1和a2的優劣，從而選擇要采取的動作
2）在選擇并執行完采用的動作后，模擬器會更新狀態并回傳回報值，然后將這個狀態轉移程序存盤進D，進行采樣更新網路引數，

（9）網路引數更新

①從D中抽取更新使用的樣本;
②利用神經網路計算maxQ(s2, a’)和Qold(s1,a1）;
③計算Qnew(s1,a1)，并通過Qnew(s1,a1)和Qold(s1,a1）更新網路引數

3.相關庫的介紹及安裝

（1）相關庫的簡介

①TensorFlow
1）是谷歌2015年開源的一個人工智能學習系統，主要目的是方便研究人員開展機器學習和深度神經網路方面的研究,目前這個系統更具有通用性,也可廣泛用于其他計算領域，
2）Tensorflow支持多種前端語言,包括Python(Python也是tensorflow支持最好的前端語言），因此一般大家利用python實作對tensorflow的呼叫，

②OpenCV
1）是一個開源的跨平臺的計算機視覺庫,實作了大量的影像處理和計算機視覺方面的通用演算法，
2）本實驗采用openev對采集的游戲畫面進行預處理，

③Pygame
1）是一個跨平臺的模塊,專為電子游戲設計，
2）Pygame相當于是一款游戲引擎,用戶無需撰寫大量的基礎模塊,而只需完成游戲邏輯本身就可以了，
3）本實驗的模擬器根據pygame實作

（2）相關庫的安裝
①TensorFlow：在確保網路通暢的情況下，打開windows的DoS命令列視窗，使用pip命令安裝:
pip install tensorflow

②OpenCV庫安裝：
1）在下載地址中找到opencv的相關下載鏈接，依據Python的具體版本下載對應的檔案，
2）找到下載的檔案的路徑,打開windows的DOS命令列視窗,使用如下命令:
pip install opencv_python-3.2.0-cp35-cp35m-win_amd64.whl
3）如果未提示任何安裝錯誤,則說明安裝成功，

③Pygame庫安裝
1）在確保網路通暢的情況下，打開windows的DOS命令列視窗,使用如下命令:
pip install pygame

（3）測驗
打開windows的DOS命令列視窗,進入Python命令列模式,匯入包測驗,如無錯誤,則說明安裝成功

4.專案實戰

（1）tensorflow基本使用

①理解TensorFlow:
1）使用圖(graph)來表示計算任務;
2）在被稱之為會話(Session)的背景關系(context）中執行圖;
3）使用tensor(張量)表示資料;
4）通過變數(Variable）維護狀態;
5）使用feed和fetch可以為任意的操作(arbitrary operation)賦值或者從其中獲取資料，

②TensorFlow是一個編程系統,使用圖來表示計算任務，圖中的節點被稱作op (Operation ) , op可以獲得0個或多個tensor,產生0個或多個tensor，

③每個tensor是一個型別化的多維陣列，
④例如:可以將一組影像集表示成一個四維的浮點陣列，四個維度分別是[batch,height,weight,channels]，
⑤圖(graph)描述了計算的程序，為了進行計算，圖必須在會話中啟動,會話負責將圖中的op分發到CPU或GPU上進行計算,然后將產生的tensor回傳，在Python中,tensor就是numpy.ndarray物件，

⑥TensorFlow程式通常被組織成兩個階段:構建階段和執行階段，
1）構建階段:op的執行順序被描跡成一個圖
2）執行階段:使用會話執行圖中的op，
3）例如:通常在構建階段創建一個圖來表示神經網路,在執行階段反復執行圖中的op訓練神經網路，

import tensorflow as tf
mat1 = tf.constant([[3.,3.]]) #創建一個1*2的矩陣
mat2 = tf.constant([[2.,2.]]) #創建一個2*1的矩陣
product = tf.matmul(mat1,mat2) #創建op執行兩個矩陣的演算法
sess = tf.session() #啟動默認圖
res = sess.run(product) #在，默認圖中執行op操作
print(res)
sess.close()

⑦互動式會話(InteractiveSession):
為了方便使用Ipython之類的Python互動環境,可以使用互動式會話(InteractiveSession）來代替Session,使用類似Tensor.run()Operation.eval()來代替Session.run()，避免使用一個變數來持有會話，

import tensorflow as tf
sess = tf.InteractiveSession #創建互動式會話
a = tf.Variable([1.0,2.0]) #創建變數陣列
b = tf.constant([3.0,4.0]) #創建常量陣列
sess.run(tf.global_variables_initializer())#變數初始化
res = tf.add(a,b)#創建加法操作
print(res.eval())#執行操作并輸出結果

（2）Feed操作:
①前面的例子中,資料均以變數或常量的形式進行存盤，
②Tensorflow還提供了Feed機制,該機制可以臨時替代圖中任意操作中的tensor，
③最常見的用例是使用tf.placeholder()創建占位符,相當于是作為圖中的輸人
④然后使用Feed機制向圖中占位符提供資料進行計算,具體使用方法見接下來的樣例，

import tensorflow as tf
sess = tf.InteractiveSession()#創建互動式會話
input1 = tf.placeholder(tf.float32)#創建占位符
input2 = tf.placeholder(tf.float32)
res = tf.mul(input1,input2)#創建乘法操作
res.eval(feed_dict={input1:[7.],input2:[2.]})#求值

（3）自主學習flappy bird實體程式撰寫
①建立工程，匯入相關工具包
②設定超引數
③創建深度神經網路
④訓練深度神經網路
⑤開啟整個訓練程序（創建互動式會話）

#建立工程，匯入相關工具包
import cv2 #匯入opencv
import sys
import tensorflow as tf
sys.path.append("game/") #添加game目錄到系統環境變數
from pygame import wrapped_flappy_bird as game#加載游戲
import random #加載隨機模塊
import numpy as np
from collections import deque#匯入雙端佇列

#設定超引數
GAME = 'bird'#設定游戲名稱
ACTIONS = 2#設定游戲動作數目
GAMMA = 0.99 #設定增強學習更新公式中的累計折扣因子
OBSERVE = 10000 #觀察期，1萬次迭代（隨機指定動作獲得d)
EXPLORE = 2000000 #探索期
FINAL_EPSILON = 0.0001#設定ε的最小值
INITIAL_EPSILON = 0.1#設定ε貪心策略中ε的初始值
REPLAY_MEMORY = 50000#設定容量
BATCH = 32 #設定每次網路引數更新時用的樣本數目
FRAME_PER_ACTION = 1 #設定幾幀影像進行一次動作


# 創建深度神經網路
#首先定義一個函式用于生成形狀為shape的張量（高維陣列）
def weight_variable(shape):
    initial = tf.truncated_normal(shape,stddev=0.01)#張量中的初始化數值服從正態分布，且方差為0.01
    return tf.Variable(initial)
#生成另一個函式用于生成偏置項，初始值為0.01
def bias_variable(shape):
    initial = tf.constant(0.01,shape = shape)
    return tf.Variable(initial)
#定義卷積操作，實作卷積核W在資料x上卷積操作
def conv2d(x,W,stride):
    return tf.nn.conv2d(x,W,strides=[1,stride,stride,1],padding = "SAME")#strides為卷積核的移動步長，padding為卷積的一種模式，引數為same表示滑動范圍超過邊界時
#定義池化函式，呼叫max_pool執行最大池化操作，大小為2*2，stride步長為2
def max_pool_2x2(x):
    return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding="SAME")

# 創建深度神經網路之定義網路結構（具體引數可回顧之前的框架）
def createNetwork(): #定義深度神經網路的引數和偏置
    #第一個卷積層
    W_conv1 = weight_variable([8,8,4,32])
    b_conv1 = bias_variable([32])
    # 第二個卷積層
    W_conv2 = weight_variable([4,4,32,64])
    b_conv2 = bias_variable([64])
    # 第三個卷積層
    W_conv3 = weight_variable([3,3,64,64])
    b_conv3 = bias_variable([64])
    #第一個全連接層
    W_fc1 = weight_variable([1600,512])
    b_fc1 = bias_variable([512])
    # 第二個全連接層
    W_fc2 = weight_variable([512,ACTIONS])
    b_fc2 = bias_variable([ACTIONS])
    #輸入層
    s = tf.placeholder("float",[None,80,80,4])#placeholder用于占位，可用作網路的輸入
    #隱藏層(對各層進行連接）
    h_conv1 = tf.nn.relu(conv2d(s,W_conv1,4) + b_conv1)
    h_pool1 = max_pool_2x2(h_conv1)

    h_conv2 = tf.nn.relu(conv2d(h_pool1,W_conv2,2) + b_conv2)
    h_conv3 = tf.nn.relu(conv2d(h_conv2, W_conv3, 1) + b_conv3)

    h_conv3_flat = tf.reshape(h_conv3,[-1,1600])

    h_fc1 = tf.nn.relu(tf.matmul(h_conv3_flat,W_fc1)+b_fc1)

    #輸出層
    readout = tf.matmul(h_fc1,W_fc2)+b_fc2


#訓練深度神經網路
def tarinNetwork(s,readout,h_cf1,sess):
    #定義損失函式
    a = tf.placeholder("float,"[None,ACTIONS])
    y = tf.placeholder("float,"[None])
    readout_action = tf.reduce_sum(tf.multiply(readout,a),reduction_indices=1)

    cost = tf.reduce_mean(tf.square(y-readout_action))
    train_step = tf.train.AdamOptimizer(1e-6).minimize(cost)

    #開啟游戲模擬器，會打開一個視窗，實時顯示游戲的資訊
    game_state = game.GameState()

    #創建雙端佇列用于存放relay memory
    D = deque()

    #獲取游戲的初始狀態，設定動作為不執行跳躍，并將初始狀態修改成80*80*4大小
    #此處需用OpenCV對影像進行預處理
    do_nothing = np.zeros(ACTIONS)
    do_nothing[0] = 1 #不執行跳躍
    x_t,r_0,terminal = game_state.frame_step(do_nothing)
    x_t = cv2.cvtColor(cv2.resize(x_t,(80,80)),cv2.COLOR_BGR2GRAY)
    ret,x_t = cv2.threshold(x_t,1,255,cv2.THRESH_BINARY) #將像素值大于等于1的像素點處理成255，也就是黑白二值圖
    s_t = np.stack((x_t,x_t,x_t,x_t),axis=2) #構造4陣的原始輸入

    #用于加載或保存網路引數
    saver = tf.train.Saver()
    sess.run(tf.initializer_all_variables())
    checkpoint = tf.train.get_checkpoint_state("saved_networks")
    if checkpoint and checkpoint.model_checkpoint_path:
        saver.restore(sess,checkpoint.model_checkpoint_path)
        print("Successfully loaded:",checkpoint.model_checkpoint_path)
    else:
        print("could not find old network weights")

    #開始訓練
    epsilon = INITIAL_EPSILON
    t = 0
    while "flappy bird" !="angry bird":
        #使用epsilon貪心策略選擇一個動作
        readout_t = readout.eval(feed_dict={s:[s_t]})[0]
        a_t = np.zeros([ACTIONS])
        action_index = 0
        if t%FRAME_PER_ACTION==0:
            #執行一個隨機動作
            if random.random()<= epsilon:
                print("---------Random Action---------")
                action_index = random.randrange(ACTIONS)
                a_t[random.randrange(ACTIONS)]=1
            #由神經網路計算的Q（s，a）值選擇對應的動作
            else:
                action_index = np.argmax(readout_t)
                a_t[action_index]=1
        else:
            a_t[0] = 1 #不執行跳躍動作
    #隨游戲的進行，不斷降低epsilon，減少隨機動作
    if epsilon>FINAL_EPSILON and t>OBSERVE:
        epsilon-=(INITIAL_EPSILON-FINAL_EPSILON)/EXPLORE
    #執行選擇的動作，并獲得下一狀態及回報
    x_t1_colored,r_t,terminal = game_state.frame_step(a_t)
    x_t1 = cv2.cvtColor(cv2.resize(x_t1_colored,(80,80)),cv2.COLOR_BGR2GRAY)

    ret,x_t1 = cv2.threshold(x_t1,1,255,cv2.THRESH_BINARY)
    x_t1 = np.reshape(x_t1,(80,80,1))
    s_t1 = np.append(x_t1,s_t[:,:,:3],axis=2)

    #將狀態轉移程序存盤到D中，用于更新引數時采樣
    D.append((s_t,a_t,r_t,s_t1,terminal))
    if len(D)>REPLAY_MEMORY:
        D.popleft()

    #過了觀察期，才會進行網路引數的更新
    if t>OBSERVE:
        # 從D中隨機采樣，用于引數更新
        minibatch = random.sample(D,BATCH)

    # 分別將當前狀態、采取的動作、獲得的回報、下一狀態分組存放
    s_j_batch = [d[0] for d in minibatch]
    a_batch = [d[1] for d in minibatch]
    r_batch = [d[2] for d in minibatch]
    s_j1_batch = [d[3] for d in minibatch]

    #計算Q(s,a)的新值
    y_batch = []
    readout_j1_batch = readout.eval(feed_dict={s: s_j1_batch})
    for i in range(0,len(minibatch)):
        terminal = minibatch[i][4]
        #如果游戲結束，則只有反饋值
        if terminal:
            y_batch.append(r_batch[i])
        else:
            y_batch.append(r_batch[i]+GAMMA*np.max(readout_j1_batch[i]))
    #使用梯度下降更新網路引數
    train_step.run(feed_dict={
        y:y_batch,
        a:a_batch,
        s:s_j_batch}
    )
    #狀態發生改變，用于下次回圈
    s_t = s_t1
    t +=1
    #每進行10000次迭代，保留一下網路引數
    if t%10000==0:
        saver.save(sess,'saved_networks/'+GAME+'-dqn',gloabl_step=t)

    #列印游戲資訊
    state = ""
    if t<=OBSERVE:
        state = "observe"
    elif t > OBSERVE and t<= OBSERVE+EXPLORE:
        state = "explore"
    else:
        state = "train"
    print("TIMESTEP",t,"/STATE/",state,\
          "/EPSILON",epsilon,"/ACTION",action_index,"/REMARD",r_t,\
          "/Q_MAX　%"%np.max(readout_t))


#開啟整個訓練程序（創建互動式會話）
def playGame():
    sess = tf.InteractiveSession()
    s,readout,h_fc1 = createNetwork()
    tarinNetwork(s,readout,h_fc1,sess)

if __name__=="_main_":
    playGame()

5.訓練結果展示

（1）訓練引數加載
①引數訓練完成后,修改程式中的超引數INITIAL EPSILON=0,即不使用隨機動作,直接由神經網路輸出動作，
②saved networks檔案夾下，保存了最近幾次檢查點保留的網路引數,只需使用tf.train.Saver(加載引數就可以使用了，
③修改checkpoint組態檔,加載保存的網路引數,默認加載最后一次保存的引數，修改完成，運行程式即可，

（2）結果展示

三、課程總結

1.主要內容

（1）無監督學習(Unsupervised Learning )
（2）監督學習(Supervised Learning)
（3）強化學習(Reinforeement Learning，增強學習)

2.無監督學習

（1）無監督學習的兩大任務
利用無標簽的資料學習資料的分布或資料與資料之間的關系被稱作無監督學習，
①聚類(clustering)
②降維(Dimension Reduction )

（2）聚類(clustering)
①聚類(clustering）,就是根據資料的“相似性”將資料分為多類的程序，
②估算兩個不同樣本之間的相似性,通常使用的方法就是計算兩個樣本之間的“距離”
③最常用的就是歐式距離,此外還有馬氏距離，曼哈頓距離,余弦距離等，

（3）Sklearn vs.聚類
①scikit-learn庫提供的常用聚類演算法函式包含在sklearn.cluster模塊中,如:K-Means,DBSCAN等，
②我們在前面的講解中通過實體具體講解了K-Means,DBSCAN這些經典的聚類函式的在sklearn中的使用方法，也簡單介紹了他們的演算法思想，
③對大多數聚類演算法來說,需要指定聚類的數目,DBSCAN是少數不需要指定聚類數目的演算法之一，
④K-means:對簇中心的初始化比較敏感，
⑤DBSCAN:它可以發現使用K均值不能發現的許多簇,但不適合密度變化太大的資料,而且對于高維資料,該方法也有問題,因為密度定義比較困難，

（4）降維
①降維,就是在保證資料所具有的代表性特性或者分布的情況下，將高維資料轉化為低維資料的程序，
②sklearn庫提供多種降維演算法,被封裝在sklearn.decomposition模塊中,在前面的學習中我們也展示了PCA和NMF在鳶尾花資料集和人臉資料集上的特征提取程序的相關操作，
③注意:降維方法通常用于高維資料集的探索與可視化,降維過的資料可以為其他任務作資料準備，

3.監督學習

（1）監督學習的兩大任務
利用一組帶有標簽的資料,學習從輸人到輸出的映射,然后將這種映射關系應用到未知資料上,達到分類或回歸的目的，

（2）分類
①輸入：—組有標簽的訓練資料(也稱觀察和評估)，標簽表明了這些資料(觀察）的所署類別，
②分類模型根據這些訓練資料,訓練自己的模型引數,學習出一個適合這組資料的分類器
③當有新資料(非訓練資料）需要進行類別判斷,就可以將這組新資料作為輸人送給學好的分類器進行判斷，

（3）Sklearn vs.聚類
①在分類學習個單元我們重點介紹了kNN、樸素貝葉斯、決策樹模型的基本思想,通過對分類問題的實體撰寫,實作了對不同分類演算法的呼叫,并進行了實驗對比，
②初學者經常會將分類問題和聚類問題混淆,而訓練資料有無標簽是區別這兩個問題的關鍵,在將實際問題轉換為學習問題的程序中,需要大家判斷準確,選擇合適的機器學習演算法，

（4）回歸
①是一種統計學上分析資料的方法,目的在于了解兩個或多個變數間是否相關、研究其相關方向與強度，并建立數學模型以便觀察特定變數來預測研究者感興趣的變數，
②回歸方法常被用來進行如股票趨勢預測,交通流量預測這種帶有時序資訊的資料分析上，

（5）Sklearn vs.回歸
①回歸函式主要分為兩類,線性回歸和非線性回歸，線性回歸函式主要封裝在sklearn.linear_model模塊中，如普通線性回歸、嶺回歸、Lasso，
②注意:sklearn中非線性回歸是通過利用sklearn.preprocessing模塊生成原始資料的非線性特征,在呼叫線性回歸模型將這些非線性特征按線性方式進行擬合實作的，

4.強化學習

（1）傳統強化學習模型(model-based, model-free )
（2）深度強化學習的基本思路
（3）TensorFlow的簡單使用技巧
（4）以Tensorflow實作Flappy bird游戲的自主學習的實體,通過實體的學習,可以掌握利用Tenforlow構造深度神經網路,并進行訓練以解決實際問題的能力，

總結

關于強化學習，核心在于對基本CNN神經網路的理解h餓使用，在此僅用最基礎的CNN結構為例，其余便不多做贅述，關于代碼之中的一些改進問題，由于用到庫中的其他方法，且本人能力有限，大家感興趣可自行查閱官網API，

關于Tensorflow庫的版本問題，由于1和2兩個版本函式差異較大，在用到某些函式出現bug時可以百度查找一下，部分函式被洗掉，部分使用方法有所改變，

兩點問題：
（1）代碼運行需要基礎資料支撐，py的自帶庫中有些內含所需資料，有些則沒有，本篇并未放上資料txt檔案，只是為了展示無監督學習的體系流程以作演示
（2）在庫的包匯入若發生問題，看看版本更新問題，以及部分包在近年來命名和函式有所調整，各位客官可面向百度

代碼非原創，內容乃網課課件整理所得，
如有問題，歡迎指正！

機器學習專欄的所有內容至此就結束啦，完結撒花~