Q-learning之一维世界的简单寻宝

Q-learning的算法：

（1）先初始化一个Q table，Q table的行数是state的个数，列数是action的个数。

（2）先随机选择一个作为初始状态S1,根据一些策略选择此状态下的动作，比如贪心策略，假设选择的动作为A1。

（3）判断由A1动作之后的状态S2是不是终止状态，如果是终止状态，返回的reward，相当于找到了宝藏，游戏结束，如果不是最终状态，在S2状态时选择此时使Q值最大的action作为下一步的动作。可以得到一个实际的Q值。Q(S1,A1)=R+λ*maxQ(S2)。更新Q table中的Q（S1，A1）。Q(S1,A1)=Q(S1,A1)+α*[R+λ*maxQ(S2)-Q(S1,A1)], []里面是实际的Q值减去估计的Q值。

简单的代码如下：

 #coding=utf-8
 import numpy as np
 import pandas as pd
 import time
 #计算机产生一段伪随机数，每次运行的时候产生的随机数都是一样的
 np.random.seed(2)
 #创建几个全局变量
 N_STATES=6#状态的个数，一共有六个状态0-5状态
 ACTIONS=["left","right"]#action只有两个左和右
 EPSILON=0.9#贪心策略
 ALPHA=0.1#学习率
 LAMBDA=0.9#discount factor
 MAX_EPISODEs=10#一共训练10次
 FRESH_TIME=0.1
 #初始化一个Q-table，我觉得Q-table里面的值初始化成什么样子应该不影响最终的结果
 def build_q_table(n_states,actions):
     table=pd.DataFrame(
         np.zeros((n_states,len(actions))),
         columns=actions,
     )
     # print(table)
     return(table)
 # build_q_table(N_STATES,ACTIONS)
 def choose_action(state,q_table):
     state_action=q_table.iloc[state,:]
     if (np.random.uniform()>EPSILON) or (state_action.all()==0):
         action_name=np.random.choice(ACTIONS)
     else:
         action_name=state_action.idxmax()
     return action_name
 def get_env_feedback(s,A):
     if A=="right":
         if s==N_STATES-2:
             s_="terminal"
             R=1
         else:
             s_=s+1
             R=0
     else:
         R=0
         if s==0:
             s_=s
         else:
             s_=s-1
     return s_,R
 def update_env(S,episode,step_couter):
     env_list=["-"]*(N_STATES-1)+["T"]
     if S=="terminal":
         interaction="Episode %s:total_steps=%s"%(episode+1,step_couter)
         print("\r{}".format(interaction),end='')
         time.sleep(2)
         print('\r                        ',end='')
     else:
         env_list[S]=''
         interaction=''.join(env_list)
         print("\r{}".format(interaction),end='')
         time.sleep(FRESH_TIME)
 def rl():
     #先初始化一个Q table
     q_table=build_q_table(N_STATES,ACTIONS)
     for episode in range(MAX_EPISODEs):
         step_counter=0
         #选择一个初始的S
         S=0
         is_terminal=False
         update_env(S,episode,step_counter)
         #如果S不是终止状态的话，选择动作，得到环境给出的一个反馈S_(新的状态)和R(奖励)
         while not is_terminal:
             A=choose_action(S,q_table)
             S_,R=get_env_feedback(S,A)
             q_predict=q_table.ix[S,A]
             if S_!="terminal":
                 #算出来实际的Q值
                 q_target=R+LAMBDA*q_table.iloc[S_,:].max()
             else:
                 q_target=R
                 is_terminal=True
             q_table.ix[S,A]+=ALPHA*(q_target-q_predict)
             S=S_
             update_env(
                 S,episode,step_counter+1
             )
             step_counter=step_counter+1
     return q_table

 if __name__=="__main__":
     q_table=rl()
     print("\r\nQ-table:\n")
     print(q_table)