Question

我正在学习q表，并通过了一个简单的版本，该版本仅使用一维数组向前和向后移动。现在我正在尝试4向运动，却无法控制人。

我现在得到了随机移动，最终它将找到目标。但我希望它学习如何达到目标，而不是随意绊脚石。因此，对于将qlearning添加到此代码中的任何建议，我将不胜感激。谢谢。

这是我的完整代码，因为它现在很简单。

import numpy as np
import random
import math

world = np.zeros((5,5))
print(world)
# Make sure that it can never be 0 i.e the start point
goal_x = random.randint(1,4)
goal_y = random.randint(1,4)
goal = (goal_x, goal_y)
print(goal)
world[goal] = 1
print(world)

LEFT = 0
RIGHT = 1
UP = 2
DOWN = 3
map_range_min = 0
map_range_max = 5

class Agent:
    def __init__(self, current_position, my_goal, world):
        self.current_position = current_position
        self.last_postion = current_position
        self.visited_positions = []
        self.goal = my_goal
        self.last_reward = 0
        self.totalReward = 0
        self.q_table = world


    # Update the totoal reward by the reward        
    def updateReward(self, extra_reward):
        # This will either increase or decrese the total reward for the episode
        x = (self.goal[0] - self.current_position[0]) **2
        y = (self.goal[1] - self.current_position[1]) **2
        dist = math.sqrt(x + y)
        complet_reward = dist + extra_reward
        self.totalReward += complet_reward 

    def validate_move(self):
        valid_move_set = []
        # Check for x ranges
        if map_range_min < self.current_position[0] < map_range_max:
            valid_move_set.append(LEFT)
            valid_move_set.append(RIGHT)
        elif map_range_min == self.current_position[0]:
            valid_move_set.append(RIGHT)
        else:
            valid_move_set.append(LEFT)
        # Check for Y ranges
        if map_range_min < self.current_position[1] < map_range_max:
            valid_move_set.append(UP)
            valid_move_set.append(DOWN)
        elif map_range_min == self.current_position[1]:
            valid_move_set.append(DOWN)
        else:
            valid_move_set.append(UP)
        return valid_move_set

    # Make the agent move
    def move_right(self):
        self.last_postion = self.current_position
        x = self.current_position[0]
        x += 1
        y = self.current_position[1]
        return (x, y)
    def move_left(self):
        self.last_postion = self.current_position
        x = self.current_position[0]
        x -= 1
        y = self.current_position[1]
        return (x, y)
    def move_down(self):
        self.last_postion = self.current_position
        x = self.current_position[0]
        y = self.current_position[1]
        y += 1
        return (x, y)
    def move_up(self):
        self.last_postion = self.current_position
        x = self.current_position[0]
        y = self.current_position[1]
        y -= 1
        return (x, y)

    def move_agent(self):
        move_set = self.validate_move()
        randChoice = random.randint(0, len(move_set)-1)
        move = move_set[randChoice]
        if move == UP:
            return self.move_up()
        elif move == DOWN:
            return self.move_down()
        elif move == RIGHT:
            return self.move_right()
        else:
            return self.move_left()

    # Update the rewards
    # Return True to kill the episode
    def checkPosition(self):
        if self.current_position == self.goal:
            print("Found Goal")
            self.updateReward(10)
            return False
        else:
            #Chose new direction
            self.current_position = self.move_agent()
            self.visited_positions.append(self.current_position)
            # Currently get nothing for not reaching the goal
            self.updateReward(0)
            return True


gus = Agent((0, 0) , goal)
play = gus.checkPosition()
while play:
    play = gus.checkPosition()

print(gus.totalReward)

Answer 1

根据您的代码示例，我有一些建议：

将环境与代理分开。环境需要具有new_state, reward = env.step(old_state, action)形式的方法。这种方法说的是动作如何将您的旧状态转换为新状态。将状态和动作编码为简单的整数是个好主意。我强烈建议为此方法设置单元测试。
然后，代理需要具有等效的方法action = agent.policy(state, reward)。首先，您应该手动编写执行您认为正确的代理程序。例如，它可能只是尝试前往目标位置。
考虑状态表示是否为马尔可夫问题。如果您可以记忆所有访问过的过去状态，则可以更好地解决该问题，则该状态不具有Markov属性。最好，状态表示应该紧凑（最小的集合仍然是马尔可夫模型）。
一旦建立了此结构，您就可以考虑实际学习Q表了。蒙特卡洛是一种可能的方法（易于理解，但不一定那么有效），它既可以探索起点，也可以探索epsilon软贪婪。一本好的RL书籍应该为这两种变体提供伪代码。

当您感到有信心时，请前往openai体育馆https://gym.openai.com/了解一些更详细的课程结构。这里有一些有关创建自己的环境的提示：https://gym.openai.com/docs/#environments

我如何更改它以使用q表进行强化学习

1 个答案: