强化学习初实践

import numpy as np
import pandas as pd
import time
#1.定义Q表  2.定义action    3.定义action的选择   4.定义Q的更新（涉及reward的定义，以及greedy参数定义）



#input :
#S_num：状态的个数
#action_all：action名称列表。如[right,left]
#output: 输出为Q表
def Q_table(S_num,action_all):  #定义Q表·易错点：np.zeros 使用时，其表示维数的参数应该使用一个元组
    Q_tab = pd.DataFrame(np.zeros((S_num,len(action_all))),columns = action_all)
    return Q_tab

#input:
#Q_table: Q表
#greedy: 贪心系数，随机探索
#S: 目前所在的状态
#output: 所选取的action
def action_choose(Q_tab,greedy,S):
    state_action = Q_tab.iloc[S,:]
    if (np.random.uniform() > greedy) or (all(Q_tab) == 0):  # np.random.uniform(low, high , size) 从均匀分布的模型中选取size个值，模型的上限值为high，下限值为low，low,high,size 的默认值为：0，1，1
        action =  np.random.choice(Q_tab.columns)
    else:
        action = state_action.idxmax() #idxmax是numpy中的一个函数，所选取的对象为dataframe。表示选取dataframe中某一行的最大值的column的名字。   array选取最大值则可通过argmax来选取
    return action

#input:
#S_num:状态数
#S:目前状态
#action:所进行的动作
#output：
#S_：进行动作后的状态
#返回进行action后的状态值
#奖励函数要根据实际模型进行定义
def get_env_feedback(S_num,S,action):
    if action ==  'right':
        if S == S_num - 2:
            S_ = 'terminal'
            R = 1
        else :
            S_ = S+1
            R = -1
    else:
        if S == 0:
            S_ = 0
            R = -1
        else:
            S_ = S-1
            R = -1
    return  S_,R


def update_env(S, episode, step_counter):
    # This is how environment be updated
    env_list = ['-']*(S_num-1) + ['T']   # '---------T' our environment
    if S == 'terminal':
        env_list[S_num-1] = 'o'
        interaction = 'Episode %s: total_steps = %s' % (episode+1, step_counter)
        print('\r{}'.format(interaction), end='')
        time.sleep(2)
        print('\r                                ', end='')

    else:
        env_list[S] = 'o'
        interaction = ''.join(env_list)
        print('\r{}'.format(interaction), end='')
        time.sleep(FRESH_TIME)

#q_predict 是在q表中的值，而 q_target 是根据 reward 及下一次的S的最大Q值的和。考虑终点的情况，终点只有一个reward，没有下一次的状态的最大Q值。
# q_predict  = Q_tab.loc[S,action] #q表中的值,进行切片，使用 [ ]
# q_target = R + Q_tab.iloc[S_,:].max() #q_target 是根据 reward 及下一次的S的最大Q值的和####选取具体某一列或者行的值，使用iloc
# Q_tab.loc[S,action] = Q_tab(S,action) + ALPHA * (q_target - q_predict) #更新####选取具体某一个值，使用loc

max_episode = 10
action_all = ['right','left']
S_num = 6
FRESH_TIME = 0.3    # 移动间隔时间
greedy = 0.9
ALPHA = 0.7
def rl():
    Q_tab = Q_table(S_num , action_all)
    for episode  in range(max_episode): #稀疏反馈，只有在最终的目的点有反馈，因此每次迭代都要从头开始走一轮，要走到最终的目标位置。
        S = 0
        step_counter = 0
        update_env(S, episode, step_counter)
        get_terminal = False
        while  not get_terminal:
            step_counter += 1
            action = action_choose(Q_tab, greedy, S)
            S_, R = get_env_feedback(S_num, S, action)  # 返回此action的反馈，即奖励和状态
            q_predict = Q_tab.loc[S, action]
            if S_ == 'terminal':
                get_terminal = True
                q_target = R
            else:
                q_target = R + 0.7*Q_tab.iloc[S_, : ].max() #
            Q_tab.loc[S, action] = Q_tab.loc[S, action] + ALPHA * (q_target - q_predict) #更新Q
            print(Q_tab)
            S = S_
            update_env(S, episode, step_counter)
rl()