人工智能之计算最佳策略（Policy Iteration and Value Iteration)

1. 实验要求

题目：计算最佳策略在下面例子基础上，自行设计一个问题（例如:求解某两点之间的最短路径，或是在图中加一些障碍物，计算最短路径），给出该问题对应的 MDP 模型描述，然后分别使用 value iteration 和 policy iteration 算法计算出最佳策略。

2．实验思路

（1）设计问题（MDP描述）

设计4*4的方格，即初始化的矩阵，每个空格都是一个状态，存在收益情况，在每到达一个点时便可选择上下左右四个方向移动，遇到边缘时状态不变，当移动一步则收益-1

（2）实验思路

设计2个矩阵Matrix1和Matrix2，用来存放上次迭代的收益值，每次走完一步先更新Matrix2，再将值赋给Matrix1，收益值由上下左右操作后得到。

As for the Policy Iteration:

(1) Initialization the Matrix1

(2) Update the value according to the function:

(delta)

(3) Until the strategy unchanged, it’s restrained.

As for the Value Iteration:

(1) Initialize the Matrix1

(2) Update the value according to the function:

(delta)

(3) Output the value function, and obtain the best strategy.

3.实验结果

Policy Iteration:

Value Iteration;

class State(object):

    def __init__(self,i,j):

    self.up = 0.25

    self.down = 0.25

    self.left = 0.25

    self.right = 0.25

    if i > 0:

    self.upState = (i - 1, j)

    else:

    self.upState = (i, j)

    if i < 3:

    self.downState = (i + 1, j)

    else:

    self.downState = (i, j)

    if j > 0:
            self.leftState = (i, j - 1)
        else:
            self.leftState = (i,j)
        if j < 3:
            self.rightState = (i, j + 1)
        else:
            self.rightState = (i, j)
        # Add barrier in position(1, 2) and (2, 1)

        if i == 2 and j == 2:
            self.upState = (i, j)
            self.leftState = (i, j)
        if i == 3 and j == 1:
            self.upState = (i, j)
        if i == 2 and j == 0:
            self.rightState = (i, j)
        if i == 1 and j == 1:
            self.rightState = (i, j)
            self.downState = (i, j)
        if i == 0 and j == 2:
            self.downState = (i, j)
        if i == 1 and j == 3:
            self.leftState = (i, j)

    def updatePolicy(self, rewardMatrix):

        oldUp = self.up
        oldDown = self.down
        oldLeft = self.left
        oldRight = self.right

        upValue = -1 + rewardMatirx[self.upState[0]][self.upState[1]]
        downValue = -1 + rewardMatirx[self.downState[0]][self.downState[1]]
        leftValue = -1 + rewardMatirx[self.leftState[0]][self.leftState[1]]
        rightValue = -1 + rewardMatirx[self.rightState[0]][self.rightState[1]]
        if(upValue >= downValue)and(upValue >= leftValue)and(upValue >= rightValue):
            self.up = 1.0
            self.down = 0
            self.left = 0
            self.right = 0
        elif(downValue >= upValue)and(downValue >= leftValue)and(downValue >= rightValue):
            self.up = 0
            self.down = 1.0
            self.left = 0
            self.right = 0
        elif(leftValue >= upValue)and(leftValue >= downValue)and(leftValue >= rightValue):
            self.up = 0
            self.down = 0
            self.left = 1.0
            self.right = 0
        else:
            self.up = 0
            self.down = 0
            self.left = 0
            self.right = 1.0
        if(oldUp == self.up)and(oldDown == self.down)and(oldLeft == self.left)and(oldRight == self.right):
            return True
        else:
            return False

################################################################################################################
# Update the reward matrix
def updateReward(i, j):
    tempMatrix[i][j] = -1 + stateMatirx[i][j].up * rewardMatirx[stateMatirx[i][j].upState[0]][stateMatirx[i][j].upState[1]]                           + stateMatirx[i][j].down * rewardMatirx[stateMatirx[i][j].downState[0]][stateMatirx[i][j].downState[1]]                           + stateMatirx[i][j].left * rewardMatirx[stateMatirx[i][j].leftState[0]][stateMatirx[i][j].leftState[1]]                           + stateMatirx[i][j].right * rewardMatirx[stateMatirx[i][j].rightState[0]][stateMatirx[i][j].rightState[1]]

#################################################################################################################
# Initialize the state matrix
stateMatirx = [[] for i in range(4)]
for i in range(4):
    for j in range(4):
        stateMatirx[i].append(State(i, j))

################################################################################################################
# Initialize the reward matrix
rewardMatirx = [
    [0,0,0,0],
    [0,0,0,0],
    [0,0,0,0],
    [0,0,0,0]
]
# The matrix used to backup reward matrix
tempMatrix = [
    [0,0,0,0],
    [0,0,0,0],
    [0,0,0,0],
    [0,0,0,0]
]
#################################################################################################################
thresh = 0   # set a threshold value here
#################################################################################################################
# Policy iteration
stableFlag = True
while stableFlag:
    # policy evaluation
    delta = 0
    for i in range(0, 4):
        for j in range(0, 4):
            if ((i == 0) and (j == 0)):
                continue
            if i == 1 and j == 2:
                continue
            if i == 2 and j == 1:
                continue
            else:
                v = tempMatrix[i][j]
                updateReward(i, j)
                delta = max(delta, abs(tempMatrix[i][j] - v))
    rewardMatirx = tempMatrix
    while delta > thresh:
        delta = 0
        for i in range(0,4):
            for j in range(0,4):
                if((i == 0)and(j == 0)):
                    continue
                if i == 1 and j == 2:
                    continue
                if i == 2 and j == 1:
                    continue
                else:
                    v = tempMatrix[i][j]
                    updateReward(i, j)
                    delta = max(delta, abs(tempMatrix[i][j] - v))
        rewardMatirx = tempMatrix
    # improve the policy
    for i in range(0,4):
        for j in range(0,4):
            if (i == 0) and (j == 0):
                continue
            if i == 1 and j == 2:
                continue
            if i == 2 and j == 1:
                continue
            else:
                stableFlag = (stableFlag and stateMatirx[i][j].updatePolicy(rewardMatirx))

    stableFlag = not stableFlag
################################################################################################################
for i in range(0, 4):
    for j in range(0, 4):
        print(rewardMatirx[i][j])
        print(" ")
    print("\n")

#设置名为Operation的类存放信息
class Operation(object):

    def __init__(self,i,j):

        self.up = 0.25#概率为0.25

        self.down = 0.25#概率为0.25

        self.left = 0.25#概率为0.25

        self.right = 0.25#概率为0.25

        if i > 0:

            self.upState = (i - 1, j)

        else:

            self.upState = (i, j)

        if i < 3:

            self.downState = (i + 1, j)

        else:

            self.downState = (i, j)

        if j > 0:

            self.leftState = (i, j - 1)

        else:

            self.leftState = (i,j)

        if j < 3:

            self.rightState = (i, j + 1)

        else:

            self.rightState = (i, j)

# 初始化收益矩阵

rewardMatrix = [

    [0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]

]

tempMatrix = [

    [0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]

]

# 初始化状态矩阵

stateMatirx = [[] for i in range(4)]

for i in range(4):

    for j in range(4):

        stateMatirx[i].append(Operation(i, j))

def updateReward(i,j):

    tempMatrix[i][j] = max((-1 + rewardMatrix[stateMatirx[i][j].upState[0]][stateMatirx[i][j].upState[1]] ),

                        (-1 + rewardMatrix[stateMatirx[i][j].downState[0]][stateMatirx[i][j].downState[1]]) ,

                        (-1 + rewardMatrix[stateMatirx[i][j].leftState[0]][stateMatirx[i][j].leftState[1]]),

                        (-1 + rewardMatrix[stateMatirx[i][j].rightState[0]][stateMatirx[i][j].rightState[1]]))

#Value iteration

thresh = 0 # 设置阈值

delta = 0

for i in range(4):

    for j in range(4):

        if ((i == 0) and (j == 0)):

            continue

        if i == 1 and j == 2:

            continue

        if i == 2 and j == 1:

            continue

        else:

            v = rewardMatrix[i][j]

            updateReward(i,j)

            delta = max(delta, abs(v - tempMatrix[i][j]))

rewardMatrix = tempMatrix

while delta > thresh:

    delta = 0

    for i in range(4):

        for j in range(4):

            if i == 0 and j == 0:

                continue

            if i == 1 and j == 2:

                continue

            if i == 2 and j == 1:

                continue

            else:

                v = rewardMatrix[i][j]

                updateReward(i, j)

                delta = max(delta, abs(v - tempMatrix[i][j]))

    rewardMatrix = tempMatrix

#输出结果矩阵

for i in range(0, 4):

    for j in range(0, 4):

        print(rewardMatrix[i][j])

        print(" ")

    print("\n")

时间： 2024-12-23 08:41:45

人工智能之计算最佳策略（Policy Iteration and Value Iteration)的相关文章

人工智能之计算最佳策略

1. 实验要求题目:计算最佳策略在下面例子基础上,自行设计一个问题(例如:求解某两点之间的最短路径, 或是在图中加一些障碍物,计算最短路径), 给出该问题对应的 MDP 模型描述, 然后分别使用 value iteration 和 policy iteration 算法计算出最佳策略. 2．实验思路 (1)设计问题(MDP描述) 设计4*4的方格,即初始化的矩阵,每个空格都是一个状态,存在收益情况,在每到达一个点时便可选择上下左右四个方向移动,遇到边缘时状态不变,当移动一步则收益-1 (2)

Unity开发实战探讨-资源的加载释放最佳策略简要心得

Unity开发实战探讨-资源的加载释放最佳策略简要心得看过我另外一篇关于Unity资源释放随笔<Unity开发实战探讨-资源的加载释放最佳策略>如果觉得略微复杂,那么下面是一些比较简要的心得体会: 概括常用资源加载的方法有三种:静态,Resources内部资源,AssetBundle外部资源资源释放的方式有二种:立刻释放和统一释放. 静态静态就是资源直接放场景,静态资源无法立刻释放,但场景关闭由引擎统一释放,开发者无法干预,所以最为无脑. 但静态过于死板,除了整个场景生命周期中必须使

上海云栖—人工智能-视觉计算专场预热

原文链接摘要: 云栖大会在走过深圳.南京.成都后,即将于6月10号11号在上海隆重召开! 在之前的三场,我们都为大家带来的是阿里人工智能全线产品的分享,此次在上海为大家带来视觉计算的专场. 因为深度学习技术的发展.计算能力的提升和视觉数据的增长,视觉智能计算技术在不少应用当中取得了令人瞩目的成绩. 云栖大会在走过深圳.南京.成都后,即将于6月10号11号在上海隆重召开! 在之前的三场,我们都为大家带来的是阿里人工智能全线产品的分享,此次在上海为大家带来视觉计算的专场. 因为深度学习技术

计算练习—策略模式

Calculate计算类: public abstract class Calculate //抽象类 Calculate { private double a;//第一个数 public double A//封装字段 { get { return a; } set { a = value; } } private double b;//第二个数字段封装 public double B { get { return b; } set { b = value; } } public double

Python将是人工智能时代的最佳编程语言

移动互联网取代PC互联网领跑在互联网时代的最前沿,Android和iOS一度成为移动互联网应用平台的两大霸主,成为移动开发者首选的两门技术,HTML5以其跨平台的优势在移动互联网应用平台占据重要位置,可以说是后来者居上. 由于技术的限制难以催生出更多的新应用,互联网+的产品日渐饱和,移动互联网从巅峰时代逐渐趋于平缓发展,下一个时代谁是主场?下一门应用技术谁来掌门? 在第三届互联网大会中百度CEO李彦宏曾表述:靠移动互联网的风口已经没有可能再出现独角兽了,因为市场已经进入了一个相对平稳的发展阶段

找对象的最佳策略，诺贝尔奖研究告诉你该怎么做

传统上,女性在找对象时喜欢守株待兔.然而,根据获得2012年诺贝尔经济奖的罗斯教授的研究,女性这样做是很吃亏的.因为,男女双方找对象的自然过程,和罗斯所研究的推迟接受算法很相似.推迟接受算法给出了两个集合(全体男性和女性)间的一个稳定匹配解,但是,这个匹配尽管是稳定的,却不是公平的.实际上,两个集合间的稳定匹配有多个解.这个算法有一个主动方和被动方,如果以男性为主动方,那么,算法得出的匹配对男性整体最有利,如果以女性为主动方,则得出的匹配对女性整体最有利.这就构成了两个极端,在这两个极端之间,通

计算器之策略模式

一.代码实现 Form1代码 namespace szys { public partial class Form1 : Form { public Form1() { InitializeComponent(); } public static int right = 0; public static int Count = 0; private int t; string path = ".\text1.txt"; int a = 0; private void button5_C

人工智能-实验一策略迭代和值迭代

1.实验问题在4x4矩阵中添加终点和障碍点,分别有一个或多个,并且满足以下属性: 终点:value值不变,始终为0,邻接点可到达用大写字母E表示障碍点:表示该点在矩阵中"不存在",邻接点不可到达该点,且该点没有value值跟状态,使用符号'#'表示以任意除以上两种结点之外的所有其它结点为起点,求解起点到终点的最短距离,存在多终点时,以相隔最近的终结点为准. 2.实验思路 1) 使用值Policy Iteration和Value Iteration算法分别计算问题产生的最佳策略

Spark入门实战系列--9.Spark图计算GraphX介绍及实例

[注]该系列文章以及使用到安装包/测试数据可以在<倾情大奉送--Spark入门实战系列>获取 1.GraphX介绍 1.1 GraphX应用背景 Spark GraphX是一个分布式图处理框架,它是基于Spark平台提供对图计算和图挖掘简洁易用的而丰富的接口,极大的方便了对分布式图处理的需求. 众所周知·,社交网络中人与人之间有很多关系链,例如Twitter.Facebook.微博和微信等,这些都是大数据产生的地方都需要图计算,现在的图处理基本都是分布式的图处理,而并非单机处理.Spark