Author: LiChong0309
Lable: Deep Learning、Artificial intelligence、Reinforcement Learing

Sarsa Algorithm的全部源代码的下载网址：
https://github.com/MorvanZhou/Reinforcement-learning-with-tensorflow/blob/master/contents/3_Sarsa_maze/maze_env.py

1.整体模块调用

整个Sarsa Algorithm使用了三个模块，run_this.py，maze_env.py，RL_brain.py

2.run_this.py

run_this.py文件中主要是update()函数，也就是Sarsa Algorithm的更新部分。

update（)函数要通过调用其他模块中的方法来得到序列[s,a,r,s_,a_]中的五个元素。然后在通过RL_brain.py模块中的learn()方法更新Q表中的值。

def update():
    #循环100次，episode = 100,有100个机会让Agent学习，如果还没有学会，就game over
    for episode in range(100):
        #初始化环境(state)    ------s
        observation = env.reset()

        #根据初始化的环境（s）得到第一个状态是的动作。 -----a
        action = RL.choose_action(str(observation))

        while True:
            # 刷新环境
            env.render()

            # 根据之前的动作得到下一步的状态-----s_
            # 根据之前的动作得到潜在奖励 -----r
            #是否终止 ----done
            observation_, reward, done = env.step(action)

            # 再根据s_选择行动（action） ------a_
            action_ = RL.choose_action(str(observation_))

            #根据序列[s,a,r,s_,a_]学习，更新Q表的参数
            RL.learn(str(observation), action, reward, str(observation_), action_)

            # 更新observation ,action
            observation = observation_
            action = action_

            # 终止时跳出循环。
            if done:
                break

    # end of game
    print('game over')
    env.destroy()

3.Maze_env.py

import numpy as np
import time
import sys    #sys.version_info.major
if sys.version_info.major == 2:      #sys.version_info.major是判断当前Python环境下的版本
    import Tkinter as tk
else:
    import tkinter as tk


UNIT = 40   # pixels    像素点
MAZE_H = 4  # grid height    网格的高
MAZE_W = 4  # grid width    网格的宽


class Maze(tk.Tk, object):    #Maze为Tkinter中的TK类的子类。

#
########################################################################
#    
    #实例化Maze类，构造函数
    def __init__(self):
        super(Maze, self).__init__()
        self.action_space = ['u', 'd', 'l', 'r']
        self.n_actions = len(self.action_space)
        self.title('maze')  #设置窗口的标题
        self.geometry('{0}x{1}'.format(MAZE_H * UNIT, MAZE_H * UNIT))   #设置窗口的大小
        self._build_maze()  #直接在Maze类的构造函数中定义控件
#
######################################################################
# 
    #搭建网格  
    def _build_maze(self):
        #创建一个canvas，窗口背景bg为白色，大小
        self.canvas = tk.Canvas(self, bg='white',
                           height=MAZE_H * UNIT,
                           width=MAZE_W * UNIT)

        # create grids     创建网格
        for c in range(0, MAZE_W * UNIT, UNIT):
            x0, y0, x1, y1 = c, 0, c, MAZE_H * UNIT
            self.canvas.create_line(x0, y0, x1, y1)
        for r in range(0, MAZE_H * UNIT, UNIT):
            x0, y0, x1, y1 = 0, r, MAZE_H * UNIT, r
            self.canvas.create_line(x0, y0, x1, y1)

        # create origin
        origin = np.array([20, 20])

        # hell 第一个黑色的矩形
        hell1_center = origin + np.array([UNIT * 2, UNIT])
        self.hell1 = self.canvas.create_rectangle(
            hell1_center[0] - 15, hell1_center[1] - 15,
            hell1_center[0] + 15, hell1_center[1] + 15,
            fill='black')
        # hell 第二个黑色的矩形
        hell2_center = origin + np.array([UNIT, UNIT * 2])
        self.hell2 = self.canvas.create_rectangle(
            hell2_center[0] - 15, hell2_center[1] - 15,
            hell2_center[0] + 15, hell2_center[1] + 15,
            fill='black')

        # create oval   创建黄色的圆形
        oval_center = origin + UNIT * 2
        self.oval = self.canvas.create_oval(
            oval_center[0] - 15, oval_center[1] - 15,
            oval_center[0] + 15, oval_center[1] + 15,
            fill='yellow')

        # create red rect     创建红色的矩形
        self.rect = self.canvas.create_rectangle(
            origin[0] - 15, origin[1] - 15,
            origin[0] + 15, origin[1] + 15,
            fill='red')

        # pack all     
        self.canvas.pack()
#
##################################################################
#
    #初始化环境，返回环境（observation）
    def reset(self):
        self.update()
        time.sleep(0.5)
        self.canvas.delete(self.rect)
        origin = np.array([20, 20])
        self.rect = self.canvas.create_rectangle(
            origin[0] - 15, origin[1] - 15,
            origin[0] + 15, origin[1] + 15,
            fill='red')
        # return observation  返回observation
        return self.canvas.coords(self.rect)

#
################################################################
#
    #根据之前的action获得下一个状态s_,潜在奖励r，是否终止标志done
    #返回值为observation_, reward ,done
    #observation_为list类型,reward为int类型，done为bool类型
    def step(self, action):
        s = self.canvas.coords(self.rect)
        base_action = np.array([0, 0])
        if action == 0:   # up
            if s[1] > UNIT:
                base_action[1] -= UNIT
        elif action == 1:   # down
            if s[1] < (MAZE_H - 1) * UNIT:
                base_action[1] += UNIT
        elif action == 2:   # right
            if s[0] < (MAZE_W - 1) * UNIT:
                base_action[0] += UNIT
        elif action == 3:   # left
            if s[0] > UNIT:
                base_action[0] -= UNIT

        self.canvas.move(self.rect, base_action[0], base_action[1])  # move agent

        s_ = self.canvas.coords(self.rect)  # next state

        # reward function
        if s_ == self.canvas.coords(self.oval):
            reward = 1
            done = True
            s_ = 'terminal'
        elif s_ in [self.canvas.coords(self.hell1), self.canvas.coords(self.hell2)]:
            reward = -1
            done = True
            s_ = 'terminal'
        else:
            reward = 0
            done = False

        return s_, reward, done
#
############################################################################
#   
    #刷新
    def render(self):
        time.sleep(0.1)
        self.update()