Python 贝叶斯规则->；夏普红外传感器的实际应用

我有一个机器人使用红外和声纳传感器来测量距离。我建立了一个居住地图/网格。 到目前为止，我使用一个简单的基于整数的系统来“计算”单元被占用的概率。对于0和传感器读数-1之间的所有呼叫，如果传感器命中，则为+1，如果为-1。如果一个单元的数组中的数字高于阈值，则该单元被计为已占用，反之亦然，则未占用。这一切都是不确定的。（有点复杂，但基于这个想法）

我现在想知道是否值得使用基于贝叶斯定理的解决方案（下面的第一个代码片段）。大多数人都是这样做的，答案很可能是肯定的：-）

在这个具体的例子中，p1和p2是什么意思？比如说，对于红外距离传感器？当定理被解释时，我理解这些例子。但不知何故，我无法将它们转化为红外传感器的情况。（我的脑子有点卡住了） 我不知道应该在那里输入什么以及如何估计值，以及如何将它们应用于我的数组/映射

如果有人能启发我，那就太好了：-） 如果可能的话，使用一些伪代码

下面也是我当前地图处理的类

谢谢 罗伯特

贝叶斯函数——但如何应用呢

def pos(p0, p1, p2):
    return (p0 * p1)/(p0 * p1 + (1-p0) * (1-p2))

def neg(p0, p1, p2):
    return (p0 * (1-p1))/(p0 * (1-p1) + (1-p0) * p2)

我当前的地图类：

templateData = {
    'MapWidth' : 800,
    'MapHeight': 600,
    'StartPosX' : 500,
    'StartPosY' : 300,
    'StartTheta' : 0,
    'Resolution' : 5,
    'mapThresholdFree' : 126,
    'mapThresholdOcc' : 130,
    'EmptyValue' : 128,
    'mapMaxOcc' : 255,
    'mapMaxFree' : 0,
    'ServoPos' : 0,
    'CurrentPosX' : 0,
    'CurrentPosY' : 0,
    'CurrentTheta' : 0
}

templateData["MapHeight"] = templateData["MapHeight"] / templateData["Resolution"]
templateData["MapWidth"] = templateData["MapWidth"] / templateData["Resolution"]
templateData["StartPosX"] = templateData["StartPosX"] / templateData["Resolution"]
templateData["StartPosY"] = templateData["StartPosY"] / templateData["Resolution"]

#map
map=robotmap.NewRobotMap(templateData["MapWidth"],templateData["MapHeight"], templateData["Resolution"], templateData["StartPosX"],templateData["StartPosY"], templateData["StartTheta"], templateData["ServoPos"],templateData["mapMaxOcc"],templateData["mapMaxFree"],templateData["EmptyValue"])
map.clear()

class NewRobotMap(object): 
    def __init__(self, sizeX, sizeY, Resolution, RobotPosX, RobotPosY, RobotTheta, ServoPos, mapMaxOcc, mapMaxFree, EmptyValue):
        self.sizeX = sizeX 
        self.sizeY = sizeY 
        self.RobotPosX = int(RobotPosX)
        self.RobotPosY = int(RobotPosY)
        self.mapResolution = int(Resolution)
        self.StartPosX = int(RobotPosX)
        self.StartPosY = int(RobotPosY)
        self.RobotTheta = float(RobotTheta)
        self.EmptyValue = EmptyValue
        self.ServoPos = ServoPos
        self.mapMaxOcc = mapMaxOcc
        self.mapMaxFree = mapMaxFree
    def clear(self):
        self.RobotMap = [[self.EmptyValue for i in xrange(self.sizeY)] for j in xrange(self.sizeX)]
    def updateMap(self ,x ,y , Val):
        oldval = self.RobotMap[x][y]
        self.RobotMap[x][y]=self.RobotMap[x][y] + Val
        if self.RobotMap[x][y] > self.mapMaxOcc:
            self.RobotMap[x][y] = self.mapMaxOcc
        elif self.RobotMap[x][y] < self.mapMaxFree:
            self.RobotMap[x][y] = self.mapMaxFree            
        return oldval, self.RobotMap[x][y]
    def updateRobot(self,theta,x,y):
        self.RobotTheta = float(theta)
        self.RobotPosX = int(round(self.StartPosX + float(int(x)/self.mapResolution), 0))
        self.RobotPosY = int(round(self.StartPosY - float(int(y)/self.mapResolution),0))
    def getRobotPos(self):
        return self.RobotPosX, self.RobotPosY
    def display(self):
        s = [[str(e) for e in row] for row in self.RobotMap]
        lens = [len(max(col, key=len)) for col in zip(*s)]
        fmt = '\t'.join('{{:{}}}'.format(x) for x in lens)
        table = [fmt.format(*row) for row in s]
        print '\n'.join(table)
    def updateServoPos(self, newServoPos):
        self.ServoPos = newServoPos

templateData={
“地图宽度”：800，
“地图高度”：600，
“StartPosX”：500，
“StartPosY”：300，
“StartTheta”：0，
"决议":5,，
“mapThresholdFree”：126，
“mapThresholdOcc”：130，
“EmptyValue”：128，
“mapMaxOcc”：255，
“mapMaxFree”：0，
“ServoPos”：0，
“CurrentPosX”：0，
“CurrentPosY”：0，
“CurrentTheta”：0
}
templateData[“MapHeight”]=templateData[“MapHeight”]/templateData[“分辨率”]
templateData[“MapWidth”]=templateData[“MapWidth”]/templateData[“分辨率”]
templateData[“StartPosX”]=templateData[“StartPosX”]/templateData[“分辨率”]
templateData[“StartPosY”]=templateData[“StartPosY”]/templateData[“Resolution”]
#地图
map=robotmap.NewRobotMap（templateData[“MapWidth”]、templateData[“MapHeight”]、templateData[“Resolution”]、templateData[“StartPosX”]、templateData[“StartPosY”]、templateData[“ServoPos”]、templateData[“mapMaxOcc”]、templateData[“mapMaxFree”]、templateData[“EmptyValue”]）
map.clear（）
类NewRobotMap（对象）：
定义初始值（self、sizeX、sizeY、Resolution、RobotPosX、RobotPosY、RobotTheta、ServoPos、mapMaxOcc、mapMaxFree、EmptyValue）：
self.sizeX=sizeX
self.sizeY=sizeY
self.RobotPosX=int（RobotPosX）
self.RobotPosY=int（RobotPosY）
self.mapResolution=int（分辨率）
self.StartPosX=int（RobotPosX）
self.StartPosY=int（RobotPosY）
self.RobotTheta=浮动（RobotTheta）
self.EmptyValue=EmptyValue
self.ServoPos=ServoPos
self.mapMaxOcc=mapMaxOcc
self.mapMaxFree=mapMaxFree
def清除（自）：
self.RobotMap=[[self.EmptyValue for i in xrange（self.sizeY）]for j in xrange（self.sizeX）]
def更新映射（self、x、y、Val）：
oldval=self.RobotMap[x][y]
self.RobotMap[x][y]=self.RobotMap[x][y]+Val
如果self.RobotMap[x][y]>self.mapMaxOcc：
self.RobotMap[x][y]=self.mapMaxOcc
elif self.RobotMap[x][y]

在

pos

中：

• p0

  是物体存在的先验概率。这可能需要事先知道地图中对象的密度

• p1

  是给定有物体存在的情况下传感器被击中的概率（低于真正数）

• p2

  是在没有物体的情况下，传感器未被击中的概率（真负数）

因此，

1-p2

是给定物体不存在时传感器被击中的概率（假阳性）。另外，

1-p0

是没有物体存在的概率。如果我们将这些值插入Bayes规则，我们得到：

Pr(Object|Hit) = Pr(Hit|Object)Pr(Object) / ( Pr(Hit|Object)Pr(Object) + Pr(No Hit|Object)Pr(No Object)

= p1 * p0 / ( p1 * p0 + (1 - p2) * (1 - p0) )

这是您提供的

pos（）

函数

注意：如果您事先不知道地图中对象的密度，可以使用

p0=0.5

，在这种情况下，方程式简化为：

Pr(Hit|Object) / ( Pr(Hit|Object) + Pr(No Hit|Object) )
= p1 / (p1 + (1-p2))

---

我不太确定我是否明白。但是，贝叶斯方法几乎总是要求你首先收集一整组数据，以便计算先验概率（贝叶斯公式是

Pr（a | B）=Pr（B | a）Pr（a）/（Pr（B | a）Pr（a）+Pr（B |非a）Pr（非a））

）你需要已经对

Pr（a）

、

Pr（非a）

、

Pr（非a）

（B |不是A）.Hmm，好的。我现在做的是获取当前概率并加/减一些东西。所以我不需要保留历史记录。我想我可以将贝叶斯方法转换为类似的方法。我想你可能要寻找的是一个。谢谢，我也会研究卡尔曼滤波器。我对贝叶斯方法的理解是ld计算类似于“基于当前概率-比如说0.2（因此最有可能未被占用）-当前正读数不太可能（基于正/假阳性比率）-因此