[人工智能]强化学习记录一Qlearning

环境

环境就是生成一个4*4的矩阵
初始位置在(0，0)
目标位置在(3，3)
走到(3，3)给奖励200
动作空间[‘up’, ‘down’, ‘left’, ‘right’]

代码

class maze_env:
    def __init__(self,row=4,column=4):
			 # 用来表示游戏是否结束
        self.done = False		
        # 后续可传入自定义的矩阵形状
        self.row = row
        self.column = column
        # 用0填充矩阵
        self.maze = torch.zeros(self.row,self.column)
        # 用来表示目标位置
        self.target_x = row-1
        self.target_y = column-1
        # 用来表示当前的位置
        self.x = 0
        self.y = 0
        # 初始位置置为1
        self.maze[self.x][self.y] = 1

	# 可以打印矩阵看看自己的代码哪出错了
    def show_maze(self):
        print(self.maze)
	# 进行一步游戏
    def step(self,action):
        r = 0
        # 把原来的位置从1变为0
        self.maze[self.x][self.y] = 0
		# 执行相应的动作以及防止出界
        if action == 'up' and self.y >= 1:# up
            self.y -= 1
        if action == 'right' and self.y <= self.row - 2:  # right
            self.y += 1
        if action == 'left' and self.x >= 1:  # left
            self.x -= 1
        if action == 'down' and self.x <= self.column - 2:  # down
            self.x += 1
        # 把执行动作后的位置置为1
        self.maze[self.x][self.y] = 1
		# 如果执行动作后的位置为目标位置，那么游戏结束
        if self.x == self.target_x and self.y == self.target_y:
            self.done = True
            r = 200
		# 返回执行动作后的位置，奖励，是否结束的状态
        return (self.x,self.y),r,self.done

    def reset(self):
    	# 基本上和初始化是一样的
        self.done = False
        self.maze = torch.zeros(self.row,self.column)
        self.x = 0
        self.y = 0
        self.maze[self.x][self.y] = 1
        return (0, 0)

智能体

能够学习价值函数

代码

class Qlearning:
    def __init__(self, actions, learning_rate=0.1, reward_decay=0.9, e_greedy=0.9):
        self.actions = actions
        self.lr = learning_rate
        self.gamma = reward_decay
        self.epsilon = e_greedy
        self.q_table = pd.DataFrame(columns=self.actions, dtype=np.float64)

		
    def choose_action(self, observation):
        self.check_state_exist(observation)
        # 90% 选择q值最大的行为 10% 选择随机行为
        if np.random.uniform() < self.epsilon:
            state_action = self.q_table.loc[observation, :]
            # 如果动作价值一样就随机选一个
            action = np.random.choice(state_action[state_action == np.max(state_action)].index)
        else:
            # 随机选择
            action = np.random.choice(self.actions)

        return action
	# 检查状态是否在q表里，不在的话就添加
    def check_state_exist(self, state):
        if state not in self.q_table.index:
            self.q_table = self.q_table.append(
                pd.Series(
                    [0]*len(self.actions),
                    index=self.q_table.columns,
                    name=state,
                )
            )

         

    def learn(self, s, a, r, s_,done):
        self.check_state_exist(s_)
        # 预测值就是取q表对应的动作-状态的值
        q_predict = self.q_table.loc[s, a]
		# 游戏未结束
        if not done:
            q_target = r + self.gamma * self.q_table.loc[s_, :].max() 
            
        else:
            q_target = r 
        # 更新q表里的值
        self.q_table.loc[s, a] += self.lr * (q_target - q_predict) 
        

主程序

maze = maze_env()
agent = Qlearning(['up', 'down', 'left', 'right'])
# 500次游戏
for i in range(500):
    observation = maze.reset()
    action_cnt = 0
    while True:
        action = agent.choose_action(str(observation))
        observation_,r,done = maze.step(action)
        agent.learn(str(observation),action,r,str(observation_),done)
        # 状态转移
        observation = observation_
        action_cnt = action_cnt + 1
        if done:
            print(agent.q_table)
            print("一共移动了",action_cnt)
            break

最终的q表

观察在(1,0)的价值发现90%向左
观察在(0,1)的价值发现90%向下

因为有90%总是选择最优
所以它只探索到了一条最优解
即(0,0)->(0,1)->(1,1)->(1,2)->(2,2)->(3,2)->(3,3)