Python MDP策略

Question

我正试图使用​​a famous MDP library for python来实现4维跑车问题。

我们在2维轨道上有一辆赛车。

当我说4维问题时，我的意思是每个STATE都是（x，y，vx，vy），意思是：position（x，y）和SPEED（vx，vy）。 SPEED是0或1（对于每个轴），所以状态的数量是有限的且很小。

有一个起始状态和一个或多个目标状态。 当你点击“墙”时，你会回到初始状态。因为我想尽可能鼓励一个解决方案，每个可通过的区块有一个“-1”奖励，墙有“无”（如GridMDP示例），目标有“0”。

ACTION是二维的（a，b），意思是相应的轴x和轴y的加速度。行动是有限的。该动作列表是有限的，小的是：

[(0, 1), (-1, 0), (-1, 1), (0, -1), (0, 0), (1, -1), (1, 0), (1, 1), (-1, -1)] 

我建了一个类，FourDimMDPClass从MDP类继承，并进行相应的更改（类同他们在GridMDP类上面所做的链接）

为了让事情变得容易，状态转换是确定性的。意思是，T函数以概率1返回一个期望的状态（或者如果你碰到墙壁，则返回起始状态）。

我使用提供的value_iteration方法解决了MDP，然后尝试使用best_policy方法获得正确的策略。

我的问题是这样的： 由于某种原因，返回的策略是完全废话。 对于所有状态都有一个常量操作返回。此操作只是操作列表中的第一个操作。 当我更改动作列表的顺序时，总是返回新的第一个动作。

这就是发生在一个非常简单和小的轨道。

我一直在尝试调试很多小时，现在没有进展。 我试着看看所有传递给MDP机制的值，而且看起来很好。

帮助将不胜感激。

Alex

P.S. 原始数据：

Current track: 
##### 
# # 
#&#*# 
##### 

& is the starting point 
* is the goal 
# means wall (or obstacle) 

& is at (1,1) 
* is at (3,1) 

states set([ 
(1, 1, 0, 1), (3, 2, 1, 0), (3, 1, 0, 1), (2, 2, 1, 1), (1, 1, 1, 0), (3, 2, 0, 1), 
(3, 1, 1, 0), (1, 1, 0, 0), (1, 2, 1, 1), (3, 1, 0, 0), (1, 1, 1, 1), (1, 2, 0, 0), 
(3, 1, 1, 1), (1, 2, 1, 0), (2, 2, 0, 1), (1, 2, 0, 1), (3, 2, 1, 1), (2, 2, 1, 0), 
(3, 2, 0, 0), (2, 2, 0, 0)]) set 


reward { 
(0, 2, 0, 1): None, (2, 2, 1, 1): -1, (0, 3, 0, 0): None, (3, 1, 1, 0): 0, 
(4, 1, 1, 1): None, (0, 3, 1, 0): None, (1, 3, 0, 1): None, (3, 1, 0, 0): 0, 
(1, 1, 1, 1): -1, (1, 2, 0, 0): -1, (3, 0, 0, 1): None, (2, 0, 1, 0): None, 
(4, 2, 1, 1): None, (4, 1, 0, 0): None, (1, 2, 1, 0): -1, (2, 0, 0, 0): None, 
(2, 3, 1, 1): None, (0, 0, 1, 1): None, (3, 3, 0, 1): None, (2, 1, 0, 1): None, 
(4, 1, 1, 0): None, (3, 2, 0, 0): -1, (1, 0, 1, 1): None, (3, 2, 1, 0): -1, 
(0, 2, 1, 0): None, (0, 2, 0, 0): None, (0, 1, 1, 1): None, (0, 3, 0, 1): None, 
(1, 3, 1, 0): None, (3, 1, 1, 1): 0, (4, 0, 1, 0): None, (1, 3, 0, 0): None, 
(2, 2, 0, 1): -1, (1, 2, 0, 1): -1, (4, 2, 0, 1): None, (2, 0, 1, 1): None, 
(2, 3, 0, 0): None, (4, 1, 0, 1): None, (3, 3, 1, 0): None, (2, 3, 1, 0): None, 
(1, 1, 0, 1): -1, (3, 3, 0, 0): None, (3, 0, 1, 1): None, (1, 0, 0, 0): None, 
(3, 2, 0, 1): -1, (4, 3, 0, 0): None, (1, 0, 1, 0): None, (0, 0, 0, 1): None, 
(4, 0, 0, 0): None, (2, 1, 1, 1): None, (0, 2, 1, 1): None, (0, 1, 0, 0): None, 
(4, 3, 1, 0): None, (4, 2, 0, 0): None, (0, 1, 1, 0): None, (4, 0, 0, 1): None, 
(1, 3, 1, 1): None, (4, 3, 1, 1): None, (2, 2, 1, 0): -1, (4, 0, 1, 1): None, 
(2, 2, 0, 0): -1, (0, 3, 1, 1): None, (3, 1, 0, 1): 0, (2, 3, 0, 1): None, 
(1, 1, 1, 0): -1, (3, 3, 1, 1): None, (3, 0, 0, 0): None, (4, 2, 1, 0): None, 
(1, 1, 0, 0): -1, (1, 2, 1, 1): -1, (3, 0, 1, 0): None, (2, 0, 0, 1): None, 
(1, 0, 0, 1): None, (0, 0, 1, 0): None, (2, 1, 0, 0): None, (4, 3, 0, 1): None, 
(0, 0, 0, 0): None, (2, 1, 1, 0): None, (0, 1, 0, 1): None, (3, 2, 1, 1): -1 
} dict 



MDPSolution { 
(1, 1, 0, 1): -4.68559, 
(2, 2, 1, 1): -4.68559, 
(3, 2, 0, 1): -4.68559, 
(3, 1, 1, 0): -3.6855900000000004, 
(3, 1, 0, 0): 0.0, 
(1, 1, 1, 1): -4.68559, 
1, 2, 0, 0): -4.68559, 
(1, 2, 1, 0): -4.68559, 
(2, 2, 1, 0): -4.68559, 
(3, 2, 0, 0): -4.68559, 
(2, 2, 0, 0): -4.68559, 
(3, 2, 1, 0): -4.68559, 
(3, 1, 0, 1): -3.6855900000000004, 
(1, 1, 1, 0): -4.68559, 
(1, 1, 0, 0): -4.68559, 
(1, 2, 1, 1): -4.68559, 
(3, 1, 1, 1): -3.6855900000000004, 
(2, 2, 0, 1): -4.68559, 
(1, 2, 0, 1): -4.68559, 
(3, 2, 1, 1): -4.68559 
} dict 



MDPPolicy { 
(1, 1, 0, 1): (0, 1), 
(3, 2, 1, 0): (0, 1), 
(3, 1, 0, 1): None, 
(2, 2, 1, 1): (0, 1), 
(1, 1, 1, 0): (0, 1), 
(3, 2, 0, 1): (0, 1), 
(3, 1, 1, 0): None, 
(1, 1, 0, 0): (0, 1), 
(1, 2, 1, 1): (0, 1), 
(3, 1, 0, 0): None, 
(1, 1, 1, 1): (0, 1), 
(1, 2, 0, 0): (0, 1), 
(3, 1, 1, 1): None, 
(1, 2, 1, 0): (0, 1), 
(2, 2, 0, 1): (0, 1), 
(1, 2, 0, 1): (0, 1), 
(3, 2, 1, 1): (0, 1), 
(2, 2, 1, 0): (0, 1), 
(3, 2, 0, 0): (0, 1), 
(2, 2, 0, 0): (0, 1) 
} dict 

主要功能：

牛逼获得一个状态，一个动作，并返回一个状态

def T(self, state, action): 

    if (action==None): 
     new_vx = state[2] 
     new_vy = state[3] 
    else: 
     new_vx = state[2]+ action[0] 
     new_vy = state[3]+ action[1] 

    myProbStateList = [] 

    nextState = self.go(state, (state[0]+new_vx,state[1]+new_vy,new_vx,new_vy)) 
    myProbStateList.append((1.0,nextState))  

    return myProbStateList 

去获取状态，NEW_STATE。如果从状态到new_state的路由是合法的，则返回new_state。否则，返回初始状态。

def go(self,state, new_state): 
    "Return the state that results from trying to going in the new state." 

    #state1 = utils.vector_add(state, acceleration) 

    myInitState = (self.init[0],self.init[1],0,0) 

    old_loc = (state[0],state[1]) 
    new_loc = (new_state[0],new_state[1]) 

    if ((new_state in self.states) & self.track.isFreeWay(old_loc,new_loc) & self.track.in_bounds(new_state[0],new_state[1])): 
     return new_state 
    else: 
     return myInitState 

Answer 1

我想我解决了它。

请注意，包含负速度的所有状态都不存在于STATES设置中，也未预设在REWARD字典中。

这是由于初始化过程出错。