def elapseTime(self, gameState):
"""
Update beliefs for a time step elapsing.
As in the elapseTime method of ExactInference, you should use:
newPosDist = self.getPositionDistribution(self.setGhostPosition(gameState, oldPos))
to obtain the distribution over new positions for the ghost, given
its previous position (oldPos) as well as Pacman's current
position.
util.sample(Counter object) is a helper method to generate a sample from a
belief distribution
"""
"*** YOUR CODE HERE ***"
# update the particles to include the distributions over the new positions for
# the ghost with a sample
newParticles = []
for oldPos in self.particles:
newPosDist = self.getPositionDistribution(self.setGhostPosition(gameState, oldPos))
new = util.sampleFromCounter(newPosDist)
newParticles.append(new)
self.particles = newParticles
"*** END YOUR CODE HERE ***"
def elapseTime(self, gameState):
"""
Update beliefs for a time step elapsing.
As in the elapseTime method of ExactInference, you should use:
newPosDist = self.getPositionDistribution(self.setGhostPosition(gameState, oldPos))
to obtain the distribution over new positions for the ghost, given
its previous position (oldPos) as well as Pacman's current
position.
"""
particles = []
#particleWeights = util.Counter()
for i in range(self.numParticles):
# <Should I resample ? Or just use particle translation>
j = random.choice(self.particles)
newPosDist = self.getPositionDistribution(
self.setGhostPosition(gameState, j))
p = util.sampleFromCounter(newPosDist)
particles.append(p)
# Calculate w = P(z|p) in observe() - I think ..
#particleWeights[p] = self.particleWeights[j]
self.particles = particles
def elapseTime(self, gameState):
"""
Update beliefs for a time step elapsing.
As in the elapseTime method of ExactInference, you should use:
newPosDist = self.getPositionDistribution(self.setGhostPosition(gameState, oldPos))
to obtain the distribution over new positions for the ghost, given its
previous position (oldPos) as well as Pacman's current position.
util.sample(Counter object) is a helper method to generate a sample from
a belief distribution.
"""
"*** YOUR CODE HERE ***"
# particlesToReturn = []
# for oldPos in self.particles:
# newPosDist = self.getPositionDistribution(self.setGhostPosition(gameState, oldPos))
# # print newPosDist
# # print "values"
# # print newPosDist.values()
# # print "keys"
# # print newPosDist.keys()
# values = [(p) for p in newPosDist.values()]
# keys = list(newPosDist.keys())
# print values
# particlesToReturn.append(util.nSample(values, keys, 1))
# self.particles = particlesToReturn
particles = []
for oldPos in self.particles:
newPosDist = self.getPositionDistribution(self.setGhostPosition(gameState, oldPos))
particles.append(util.sampleFromCounter(newPosDist))
self.particles = particles
def observeState(self, gameState):
"""
Resamples the set of particles using the likelihood of the noisy observations.
"""
pacmanPosition = gameState.getPacmanPosition()
noisyDistances = gameState.getNoisyGhostDistances()
if len(noisyDistances) < self.numGhosts: return
emissionModels = [getObservationDistribution(dist) for dist in noisyDistances]
"*** YOUR CODE HERE ***"
WEIGHT = -1
self.particles = self.sendToJail(noisyDistances)
newParticles = []
for par in self.particles:
newParticle = list(par)
newParticle[WEIGHT] = reduce(mul, [emissionModels[i][util.manhattanDistance(pacmanPosition, newParticle[i])]
for i in range(len(emissionModels)) if noisyDistances[i] != None])
newParticles.append(tuple(newParticle))
newDistribution = util.Counter()
for par in newParticles:
newDistribution[par[:WEIGHT]] = sum(newParticle[WEIGHT] for newParticle in newParticles if newParticle[:WEIGHT] == par[:WEIGHT])
if len([par for par in newParticles if newDistribution[par[:WEIGHT]] > 0]) == 0:
self.initializeParticles()
self.particles = self.sendToJail(noisyDistances)
newDistribution = util.Counter()
for par in self.particles:
newDistribution[par[:WEIGHT]] = sum(newParticle[WEIGHT] for newParticle in self.particles if newParticle[:WEIGHT] == par[:WEIGHT])
else:
self.particles = [tuple(list(util.sampleFromCounter(newDistribution)) + [1]) for _ in range(self.numParticles)]
def observe(self, observation, gameState):
"Update beliefs based on the given distance observation."
emissionModel = busters.getObservationDistribution(observation)
pacmanPosition = gameState.getPacmanPosition()
"*** YOUR CODE HERE ***"
noisyDistance = observation
newBeliefs = util.Counter()
beliefs = self.getBeliefDistribution()
for pos in self.legalPositions:
trueDistance = util.manhattanDistance(pacmanPosition, pos)
if emissionModel[trueDistance] > 0:
newBeliefs[pos] = emissionModel[trueDistance] * beliefs[pos]
newBeliefs.normalize()
if newBeliefs.totalCount() == 0:
self.initializeUniformly(gameState, self.numParticles)
else:
self.particles = []
for i in range (0, self.numParticles):
self.particles.append(util.sampleFromCounter(newBeliefs))
if noisyDistance == 999:
self.particles = []
for i in range (0, self.numParticles):
self.particles.append(self.getJailPosition())
def observeState(self, gameState):
"""
Resamples the set of particles using the likelihood of the noisy observations.
To loop over the ghosts, use:
for i in range(self.numGhosts):
...
A correct implementation will handle two special cases:
1) When a ghost is captured by Pacman, all particles should be updated so
that the ghost appears in its prison cell, position self.getJailPosition(i)
where "i" is the index of the ghost.
You can check if a ghost has been captured by Pacman by
checking if it has a noisyDistance of None (a noisy distance
of None will be returned if, and only if, the ghost is
captured).
2) When all particles receive 0 weight, they should be recreated from the
prior distribution by calling initializeParticles. After all particles
are generated randomly, any ghosts that are eaten (have noisyDistance of 0)
must be changed to the jail Position. This will involve changing each
particle if a ghost has been eaten.
** Remember ** We store particles as tuples, but to edit a specific particle,
it must be converted to a list, edited, and then converted back to a tuple. Since
this is a common operation when placing a ghost in the jail for a particle, we have
provided a helper method named self.getParticleWithGhostInJail(particle, ghostIndex)
that performs these three operations for you.
"""
pacmanPosition = gameState.getPacmanPosition()
noisyDistances = gameState.getNoisyGhostDistances()
if len(noisyDistances) < self.numGhosts: return
emissionModels = [busters.getObservationDistribution(dist) for dist in noisyDistances]
"*** YOUR CODE HERE ***"
weighted, particles = util.Counter(), list()
for particle in self.particles:
ghostPositions, weight = list(particle), 1
for ghost in range(self.numGhosts):
manhattan = util.manhattanDistance(ghostPositions[ghost], pacmanPosition)
if noisyDistances[ghost] is None:
particle = self.getParticleWithGhostInJail(particle, ghost)
else:
weight *= emissionModels[ghost][manhattan]
weighted[particle] += weight
weighted.normalize()
if weighted.totalCount() != 0:
for i in range(self.numParticles):
particles.append(util.sampleFromCounter(weighted))
else:
self.initializeParticles()
particles = self.particles
for ghost in range(self.numGhosts):
if noisyDistances[ghost] is None:
for i in range(self.numParticles):
particles[i] = self.getParticleWithGhostInJail(self.particles[i], ghost)
self.particles = particles
def observeState(self, gameState):
"""
Resamples the set of particles using the likelihood of the noisy
observations.
To loop over the ghosts, use:
for i in range(self.numGhosts):
...
A correct implementation will handle two special cases:
1) When a ghost is captured by Pacman, all particles should be updated
so that the ghost appears in its prison cell, position
self.getJailPosition(i) where `i` is the index of the ghost.
As before, you can check if a ghost has been captured by Pacman by
checking if it has a noisyDistance of None.
2) When all particles receive 0 weight, they should be recreated from
the prior distribution by calling initializeParticles. After all
particles are generated randomly, any ghosts that are eaten (have
noisyDistance of None) must be changed to the jail Position. This
will involve changing each particle if a ghost has been eaten.
self.getParticleWithGhostInJail is a helper method to edit a specific
particle. Since we store particles as tuples, they must be converted to
a list, edited, and then converted back to a tuple. This is a common
operation when placing a ghost in jail.
"""
pacmanPosition = gameState.getPacmanPosition()
noisyDistances = gameState.getNoisyGhostDistances()
if len(noisyDistances) < self.numGhosts:
return
emissionModels = [busters.getObservationDistribution(dist) for dist in noisyDistances]
newBeliefs = util.Counter()
particles = self.particles
for i, particle in enumerate(particles):
prob = 1.0
for index in range(self.numGhosts):
emissionModel = emissionModels[index]
if noisyDistances[index] is None: # we have captured the ghost
particle = self.getParticleWithGhostInJail(particle, index)
else:
trueDistance = util.manhattanDistance(particle[index], pacmanPosition)
prob *= emissionModel[trueDistance]
newBeliefs[particle] += prob
if all(v == 0 for v in newBeliefs.values()):
self.initializeParticles()
for particle in self.particles:
for i in range(self.numGhosts):
if noisyDistances[i] is None:
particle = self.getParticleWithGhostInJail(particle, i)
else:
newBeliefs.normalize()
newParticles = []
while len(newParticles) < self.numParticles:
newParticle = util.sampleFromCounter(newBeliefs)
newParticles.append(newParticle)
self.particles = newParticles
def observeState(self, gameState):
"""
Resamples the set of particles using the likelihood of the noisy observations.
As in elapseTime, to loop over the ghosts, use:
for i in range(self.numGhosts):
...
A correct implementation will handle two special cases:
1) When a ghost is captured by Pacman, all particles should be updated so
that the ghost appears in its prison cell, position (2 * i + 1, 1),
where "i" is the 0-based index of the ghost.
You can check if a ghost has been captured by Pacman by
checking if it has a noisyDistance of 999 (a noisy distance
of 999 will be returned if, and only if, the ghost is
captured).
2) When all particles receive 0 weight, they should be recreated from the
prior distribution by calling initializeParticles.
"""
pacmanPosition = gameState.getPacmanPosition()
noisyDistances = gameState.getNoisyGhostDistances()
if len(noisyDistances) < self.numGhosts: return
emissionModels = [busters.getObservationDistribution(dist) for dist in noisyDistances]
particleWeights = util.Counter()
for particle in self.particles:
#particleWeights[particle] = 1
oldPos = list(particle)
for i in range(self.numGhosts):
p = oldPos[i]
trueDistance = util.manhattanDistance(p, pacmanPosition)
# To handle zero probabilities when in jail
#particleWeights[particle] *= emissionModels[i][trueDistance]
particleWeights[particle] += emissionModels[i][trueDistance]
particleWeights.normalize()
# Handle case for all weights are 0
if not particleWeights.totalCount():
print "Re init"
self.initializeParticles()
else :
# Resample
self.particles = []
for i in range(self.numParticles):
p = util.sampleFromCounter(particleWeights)
self.particles.append(p)
# Handle jail cells
for i in range(self.numGhosts):
if noisyDistances[i] == 999:
newParticles = []
for particle in self.particles:
oldPos = list(particle)
oldPos[i] = (2*i + 1, 1)
newParticles.append(tuple(oldPos))
self.particles = newParticles
def elapseTime(self, gameState):
"""
Samples each particle's next state based on its current state and the gameState.
To loop over the ghosts, use:
for i in range(self.numGhosts):
...
Then, assuming that "i" refers to the index of the
ghost, to obtain the distributions over new positions for that
single ghost, given the list (prevGhostPositions) of previous
positions of ALL of the ghosts, use this line of code:
newPosDist = getPositionDistributionForGhost(setGhostPositions(gameState, prevGhostPositions),
i, self.ghostAgents[i])
Note that you may need to replace "prevGhostPositions" with the
correct name of the variable that you have used to refer to the
list of the previous positions of all of the ghosts, and you may
need to replace "i" with the variable you have used to refer to
the index of the ghost for which you are computing the new
position distribution.
As an implementation detail (with which you need not concern
yourself), the line of code above for obtaining newPosDist makes
use of two helper functions defined below in this file:
1) setGhostPositions(gameState, ghostPositions)
This method alters the gameState by placing the ghosts in the supplied positions.
2) getPositionDistributionForGhost(gameState, ghostIndex, agent)
This method uses the supplied ghost agent to determine what positions
a ghost (ghostIndex) controlled by a particular agent (ghostAgent)
will move to in the supplied gameState. All ghosts
must first be placed in the gameState using setGhostPositions above.
The ghost agent you are meant to supply is self.ghostAgents[ghostIndex-1],
but in this project all ghost agents are always the same.
"""
'''
POSITION, WEIGHT = 0, 1
newParticles = []
for par in self.particles:
newPosDist = self.getPositionDistribution(self.setGhostPosition(gameState, par[POSITION]))
newParticles.append((util.sampleFromCounter(newPosDist), par[WEIGHT]))
self.particles = newParticles
'''
newParticles = []
for oldParticle in self.particles:
newParticle = list(oldParticle) # A list of ghost positions
"*** YOUR CODE HERE ***"
for i in range(self.numGhosts):
prevGhostPositions = newParticle[:-1]
newPosDist = getPositionDistributionForGhost(setGhostPositions(gameState, prevGhostPositions),
i, self.ghostAgents[i])
newParticle[i] = util.sampleFromCounter(newPosDist)
newParticles.append(tuple(newParticle))
self.particles = newParticles
def observeState(self, gameState):
"""
Resamples the set of particles using the likelihood of the noisy observations.
As in elapseTime, to loop over the ghosts, use:
for i in range(self.numGhosts):
...
A correct implementation will handle two special cases:
1) When a ghost is captured by Pacman, all particles should be updated so
that the ghost appears in its prison cell, position self.getJailPosition(i)
where "i" is the index of the ghost.
You can check if a ghost has been captured by Pacman by
checking if it has a noisyDistance of None (a noisy distance
of None will be returned if, and only if, the ghost is
captured).
2) When all particles receive 0 weight, they should be recreated from the
prior distribution by calling initializeParticles. Remember to
change ghosts' positions to jail if called for.
"""
pacmanPosition = gameState.getPacmanPosition()
noisyDistances = gameState.getNoisyGhostDistances()
if len(noisyDistances) < self.numGhosts: return
emissionModels = [busters.getObservationDistribution(dist) for dist in noisyDistances]
"*** YOUR CODE HERE ***"
allPossible = util.Counter()
#for x in xrange(0,self.numParticles):
# p = util.sampleFromCounter(self.particles)
for p in xrange(self.numParticles):
weight = 1
for i in xrange(self.numGhosts):
if noisyDistances[i]:
trueDistance = util.manhattanDistance(self.particles[p][i], pacmanPosition)
emissionModel = emissionModels[i]
#if emissionModel[trueDistance] > 0:
weight *= emissionModel[trueDistance]
allPossible[self.particles[p]] += weight
allPossible.normalize()
self.particles = []
if allPossible.totalCount() == 0:
self.initializeUniformly(self.numParticles)
else:
for i in xrange(self.numParticles):
self.particles.append(util.sampleFromCounter(allPossible))
self.newParticles = []
for p in self.particles:
p = list(p)
for i in range(self.numGhosts):
if noisyDistances[i] == None:
p[i] = self.getJailPosition(i)
self.newParticles.append(tuple(p))
self.particles = self.newParticles
def observeState(self, gameState):
"""
Resamples the set of particles using the likelihood of the noisy observations.
As in elapseTime, to loop over the ghosts, use:
for i in range(self.numGhosts):
...
A correct implementation will handle two special cases:
1) When a ghost is captured by Pacman, all particles should be updated so
that the ghost appears in its prison cell, position self.getJailPosition(i)
where "i" is the index of the ghost.
You can check if a ghost has been captured by Pacman by
checking if it has a noisyDistance of None (a noisy distance
of None will be returned if, and only if, the ghost is
captured).
2) When all particles receive 0 weight, they should be recreated from the
prior distribution by calling initializeParticles. Remember to
change ghosts' positions to jail if called for.
"""
pacmanPosition = gameState.getPacmanPosition()
noisyDistances = gameState.getNoisyGhostDistances()
if len(noisyDistances) < self.numGhosts: return
emissionModels = [busters.getObservationDistribution(dist) for dist in noisyDistances]
"*** YOUR CODE HERE ***"
weight =util.Counter()
for c in range(self.numParticles):
oldPos=list(self.particles[c])
weights = util.Counter()
for i in range(self.numGhosts):
if (noisyDistances[i]==None):
oldPos[i]=self.getJailPosition(i)
self.particles[c]=tuple(oldPos)
weights[i] = 1.0
else:
trueDistance = util.manhattanDistance(oldPos[i], pacmanPosition)
if emissionModels[i][trueDistance] > 0:
weights[i]+= emissionModels[i][trueDistance]
product=1.00
for j in range(self.numGhosts):
product*=weights[j]
weight[self.particles[c]]+=product
if weight.totalCount()==0:
self.initializeParticles()
return
resampledParticle =[]
i=0
while(i<self.numParticles):
sample=util.sampleFromCounter(weight)
resampledParticle+=[sample]
i+=1
self.particles = resampledParticle
def observe(self, observation, gameState):
"""
Update beliefs based on the given distance observation. Make
sure to handle the special case where all particles have weight
0 after reweighting based on observation. If this happens,
resample particles uniformly at random from the set of legal
positions (self.legalPositions).
A correct implementation will handle two special cases:
1) When a ghost is captured by Pacman, **all** particles should be updated so
that the ghost appears in its prison cell, self.getJailPosition()
You can check if a ghost has been captured by Pacman by
checking if it has a noisyDistance of None (a noisy distance
of None will be returned if, and only if, the ghost is
captured).
2) When all particles receive 0 weight, they should be recreated from the
prior distribution by calling initializeUniformly. The total weight
for a belief distribution can be found by calling totalCount on
a Counter object
util.sample(Counter object) is a helper method to generate a sample from
a belief distribution
You may also want to use util.manhattanDistance to calculate the distance
between a particle and pacman's position.
"""
noisyDistance = observation
emissionModel = busters.getObservationDistribution(noisyDistance)
pacmanPosition = gameState.getPacmanPosition()
"*** YOUR CODE HERE ***"
# if self.particles.totalCount()==0:
# self.initializeUniformly(self.numParticles)
flag = True
if noisyDistance == None:
belief = util.Counter()
belief[self.getJailPosition()] = 1
self.beliefs = belief
return
allPossible = util.Counter()
for elem in self.legalPositions:
trueDistance = util.manhattanDistance(elem, pacmanPosition)
if emissionModel[trueDistance] > 0:
Flag = False
allPossible[elem] = emissionModel[trueDistance] * self.particles[elem]
allPossible.normalize()
if Flag:
self.initializeUniformly(self.numParticles)
i = 0
self.particles = util.Counter()
while i!=self.numParticles:
choose = util.sampleFromCounter(allPossible)
self.particles[choose]+=1
i+=1
self.particles.normalize()
def observeState(self, gameState):
"""
Resamples the set of particles using the likelihood of the noisy observations.
To loop over the ghosts, use:
for i in range(self.numGhosts):
...
A correct implementation will handle two special cases:
1) When a ghost is captured by Pacman, all particles should be updated so
that the ghost appears in its prison cell, position self.getJailPosition(i)
where "i" is the index of the ghost.
You can check if a ghost has been captured by Pacman by
checking if it has a noisyDistance of None (a noisy distance
of None will be returned if, and only if, the ghost is
captured).
2) When all particles receive 0 weight, they should be recreated from the
prior distribution by calling initializeParticles. After all particles
are generated randomly, any ghosts that are eaten (have noisyDistance of 0)
must be changed to the jail Position. This will involve changing each
particle if a ghost has been eaten.
** Remember ** We store particles as tuples, but to edit a specific particle,
it must be converted to a list, edited, and then converted back to a tuple. Since
this is a common operation when placing a ghost in the jail for a particle, we have
provided a helper method named self.getParticleWithGhostInJail(particle, ghostIndex)
that performs these three operations for you.
"""
pacmanPosition = gameState.getPacmanPosition()
noisyDistances = gameState.getNoisyGhostDistances()
if len(noisyDistances) < self.numGhosts: return
emissionModels = [
busters.getObservationDistribution(dist) for dist in noisyDistances
]
"*** YOUR CODE HERE ***"
weighted, particles = util.Counter(), list()
for particle in self.particles:
ghostPositions, weight = list(particle), 1
for ghost in range(self.numGhosts):
manhattan = util.manhattanDistance(ghostPositions[ghost],
pacmanPosition)
if noisyDistances[ghost] is None:
particle = self.getParticleWithGhostInJail(particle, ghost)
else:
weight *= emissionModels[ghost][manhattan]
weighted[particle] += weight
weighted.normalize()
if weighted.totalCount() != 0:
for i in range(self.numParticles):
particles.append(util.sampleFromCounter(weighted))
else:
self.initializeParticles()
particles = self.particles
for ghost in range(self.numGhosts):
if noisyDistances[ghost] is None:
for i in range(self.numParticles):
particles[i] = self.getParticleWithGhostInJail(
self.particles[i], ghost)
self.particles = particles
def observeState(self, gameState):
"""
Resamples the set of particles using the likelihood of the noisy observations.
As in elapseTime, to loop over the ghosts, use:
for i in range(self.numGhosts):
...
A correct implementation will handle two special cases:
1) When a ghost is captured by Pacman, all particles should be updated so
that the ghost appears in its prison cell, position (2 * i + 1, 1),
where "i" is the 0-based index of the ghost.
You can check if a ghost has been captured by Pacman by
checking if it has a noisyDistance of 999 (a noisy distance
of 999 will be returned if, and only if, the ghost is
captured).
2) When all particles receive 0 weight, they should be recreated from the
prior distribution by calling initializeParticles.
"""
pacmanPosition = gameState.getPacmanPosition()
noisyDistances = gameState.getNoisyGhostDistances()
if len(noisyDistances) < self.numGhosts: return
emissionModels = [busters.getObservationDistribution(dist) for dist in noisyDistances]
"*** YOUR CODE HERE ***"
allWeight = util.Counter();
for p in range(self.numParticles):
weight = 0;
for i in range(self.numGhosts):
trueDistance = util.manhattanDistance(self.particles[p][i], pacmanPosition);
if emissionModels[i][trueDistance] > 0:
weight += emissionModels[i][trueDistance];
allWeight[self.particles[p]] = weight;
#allWeight.normalize();
if allWeight.totalCount() == 0:
self.initializeParticles();
else:
self.particles = [];
for j in range(self.numParticles):
self.particles.append(tuple(util.sampleFromCounter(allWeight)));
checkedParticles = [];
## check for ghost eaten by the Pacman
for p in range(self.numParticles):
particle = list(self.particles[p]);
for i in range(self.numGhosts):
if noisyDistances[i] == 999:
particle[i] = (2 * i + 1, i);
checkedParticles.append(tuple(particle));
self.particles = checkedParticles;
def observe(self, observation, gameState):
"""
Update beliefs based on the given distance observation. Make sure to
handle the special case where all particles have weight 0 after
reweighting based on observation. If this happens, resample particles
uniformly at random from the set of legal positions
(self.legalPositions).
A correct implementation will handle two special cases:
1) When a ghost is captured by Pacman, all particles should be updated
so that the ghost appears in its prison cell,
self.getJailPosition()
As before, you can check if a ghost has been captured by Pacman by
checking if it has a noisyDistance of None.
2) When all particles receive 0 weight, they should be recreated from
the prior distribution by calling initializeUniformly. The total
weight for a belief distribution can be found by calling totalCount
on a Counter object
util.sample(Counter object) is a helper method to generate a sample from
a belief distribution.
You may also want to use util.manhattanDistance to calculate the
distance between a particle and Pacman's position.
"""
noisyDistance = observation
emissionModel = busters.getObservationDistribution(noisyDistance)
pacmanPosition = gameState.getPacmanPosition()
"*** Q4 CODE STARTS HERE ***"
# util.raiseNotDefined()
jailedGhostBeliefs = util.Counter()
beliefs = self.getBeliefDistribution()
for posn in self.legalPositions:
distance = util.manhattanDistance(pacmanPosition, posn)
if emissionModel[distance] > 0:
jailedGhostBeliefs[posn] = emissionModel[distance] * beliefs[posn]
jailedGhostBeliefs.normalize()
if jailedGhostBeliefs.totalCount() == 0:
self.initializeUniformly(gameState)
else:
self.particles = []
for i in range(0, self.numParticles):
self.particles.append(util.sampleFromCounter(jailedGhostBeliefs))
if noisyDistance is None:
self.particles = []
for i in range(0, self.numParticles):
self.particles.append(self.getJailPosition())
def observe(self, observation, gameState):
"""
Update beliefs based on the given distance observation. Make
sure to handle the special case where all particles have weight
0 after reweighting based on observation. If this happens,
resample particles uniformly at random from the set of legal
positions (self.legalPositions).
A correct implementation will handle two special cases:
1) When a ghost is captured by Pacman, all particles should be updated so
that the ghost appears in its prison cell, self.getJailPosition()
You can check if a ghost has been captured by Pacman by
checking if it has a noisyDistance of None (a noisy distance
of None will be returned if, and only if, the ghost is
captured).
2) When all particles receive 0 weight, they should be recreated from the
prior distribution by calling initializeUniformly. Remember to
change particles to jail if called for.
"""
noisyDistance = observation
emissionModel = busters.getObservationDistribution(noisyDistance)
pacmanPosition = gameState.getPacmanPosition()
"*** YOUR CODE HERE ***"
value = 0
allPossible = util.Counter()
for p in self.legalPositions:
trueDistance = util.manhattanDistance(p, pacmanPosition)
if emissionModel[trueDistance] > 0:
value = 1
allPossible[p] = self.particles[p] * emissionModel[trueDistance]
allPossible.normalize()
# all weights for particles == 0
if value == 0:
self.initializeUniformly(self.numParticles)
# If ghost in jail
if noisyDistance == None:
for p in self.beliefs:
if p == self.getJailPosition():
allPossible[p] = 1.0
else:
allPossible[p] = 0.0
# Resample:
# Use the probability distribution from allPossible {Pos: probability, Pos: probability, ...}
self.particles = util.Counter()
for i in range(self.numParticles):
samplePos = util.sampleFromCounter(allPossible)
self.particles[samplePos] = self.particles[samplePos] + 1
self.particles.normalize()
def observe(self, observation, gameState):
"""
Update beliefs based on the given distance observation. Make
sure to handle the special case where all particles have weight
0 after reweighting based on observation. If this happens,
resample particles uniformly at random from the set of legal
positions (self.legalPositions).
A correct implementation will handle two special cases:
1) When a ghost is captured by Pacman, all particles should be updated so
that the ghost appears in its prison cell, self.getJailPosition()
You can check if a ghost has been captured by Pacman by
checking if it has a noisyDistance of None (a noisy distance
of None will be returned if, and only if, the ghost is
captured).
2) When all particles receive 0 weight, they should be recreated from the
prior distribution by calling initializeUniformly. Remember to
change particles to jail if called for.
"""
noisyDistance = observation
emissionModel = busters.getObservationDistribution(noisyDistance)
pacmanPosition = gameState.getPacmanPosition()
"*** YOUR CODE HERE ***"
""" compute weights, i.e. P(noise_t+1 | dist(pac, si) ), si \in self.particles """
if noisyDistance == None:
return
wts = util.Counter()
all_zero = True
for si in self.particles:
d = util.manhattanDistance(si, pacmanPosition)
wts[si] += emissionModel[d]
if wts[si] > 0.0:
all_zero = False
wts.normalize()
# print( "wts: ", wts )
# print( wts.totalCount() )
""" resample uniformly or according to wts """
if all_zero:
self.initializeUniformly(gameState)
else:
self.particles = []
for i in range(self.numParticles):
self.particles.append(util.sampleFromCounter(wts))
# print( "after resampling: ", self.particles )
return
def elapseTime(self, gameState):
"""
Samples each particle's next state based on its current state and the gameState.
"""
newParticles = []
for oldParticle in self.particles:
newParticle = list(oldParticle) # A list of ghost positions
"*** YOUR CODE HERE ***"
for i in range(self.numGhosts):
prevGhostPositions = newParticle[:-1]
newPosDist = getPositionDistributionForGhost(setGhostPositions(gameState, prevGhostPositions),
i, self.ghostAgents[i])
newParticle[i] = util.sampleFromCounter(newPosDist)
newParticles.append(tuple(newParticle))
self.particles = newParticles
def observe(self, observation, gameState):
"""
Update beliefs based on the given distance observation. Make
sure to handle the special case where all particles have weight
0 after reweighting based on observation. If this happens,
resample particles uniformly at random from the set of legal
positions (self.legalPositions).
A correct implementation will handle two special cases:
1) When a ghost is captured by Pacman, all particles should be updated so
that the ghost appears in its prison cell, self.getJailPosition()
You can check if a ghost has been captured by Pacman by
checking if it has a noisyDistance of None (a noisy distance
of None will be returned if, and only if, the ghost is
captured).
2) When all particles receive 0 weight, they should be recreated from the
prior distribution by calling initializeUniformly. Remember to
change particles to jail if called for.
"""
noisyDistance = observation
emissionModel = getObservationDistribution(noisyDistance)
pacmanPosition = gameState.getAgentPosition(self.myIndex)
"*** YOUR CODE HERE ***"
POSITION, WEIGHT = 0, 1
if noisyDistance == None:
self.particles = [(self.getJailPosition(), 1) for _ in range(self.numParticles)]
else:
newParticles = []
for par in self.particles:
newPar = (par[POSITION], emissionModel[util.manhattanDistance(pacmanPosition, par[POSITION])])
newParticles.append(newPar)
newDistribution = util.Counter()
for p in self.particles:
newDistribution[p[POSITION]] = sum([par[WEIGHT] for par in newParticles if par[POSITION] == p[POSITION]])
if len([p for p in self.legalPositions if newDistribution[p] > 0]) == 0:
self.initializeUniformly(gameState)
if noisyDistance == None:
self.particles = [(self.getJailPosition(), 1) for _ in range(self.numParticles)]
newDistribution = util.Counter()
for p in self.legalPositions:
newDistribution[p] = sum([par[WEIGHT] for par in newParticles if par[POSITION] == p])
else:
self.particles = [(util.sampleFromCounter(newDistribution), 1) for _ in range(self.numParticles)]
def observe(self, observation, gameState):
"""
Update beliefs based on the given distance observation. Make
sure to handle the special case where all particles have weight
0 after reweighting based on observation. If this happens,
resample particles uniformly at random from the set of legal
positions (self.legalPositions).
A correct implementation will handle two special cases:
1) When a ghost is captured by Pacman, all particles should be updated so
that the ghost appears in its prison cell, self.getJailPosition()
You can check if a ghost has been captured by Pacman by
checking if it has a noisyDistance of None (a noisy distance
of None will be returned if, and only if, the ghost is
captured).
2) When all particles receive 0 weight, they should be recreated from the
prior distribution by calling initializeUniformly. Remember to
change particles to jail if called for.
"""
noisyDistance = observation
emissionModel = busters.getObservationDistribution(noisyDistance)
pacmanPosition = gameState.getPacmanPosition()
"*** YOUR CODE HERE ***"
if pacmanPosition in self.getJailPosition():
allPossible[pacmanPosition]=1
self.particles=allPossible
else:
weights = util.Counter()
for p in self.particles:
trueDistance = util.manhattanDistance(p, pacmanPosition)
if emissionModel[trueDistance] > 0:
weights[p] += emissionModel[trueDistance]
weights.normalize()
if weights.totalCount()==0:
self.initializeUniformly(gameState)
return
resampledParticle =[]
i=0
while(i<self.numParticles):
sample=util.sampleFromCounter(weights)
resampledParticle+=[sample]
i+=1
self.particles = resampledParticle
def elapseTime(self, gameState):
"""
Update beliefs for a time step elapsing.
As in the elapseTime method of ExactInference, you should use:
newPosDist = self.getPositionDistribution(self.setGhostPosition(gameState, oldPos))
to obtain the distribution over new positions for the ghost, given
its previous position (oldPos) as well as Pacman's current
position.
"""
newParticlesList = []
for particle in self.particles:
newPosDist = self.getPositionDistribution(self.setGhostPosition(gameState, particle.state))
newParticle = Particle(util.sampleFromCounter(newPosDist),1.0)
newParticlesList.append(newParticle)
self.particles = newParticlesList
def elapseTime(self, gameState):
"""
Update beliefs for a time step elapsing.
As in the elapseTime method of ExactInference, you should use:
newPosDist = self.getPositionDistribution(self.setGhostPosition(gameState, oldPos))
to obtain the distribution over new positions for the ghost, given
its previous position (oldPos) as well as Pacman's current
position.
"""
"*** YOUR CODE HERE ***"
newParticles = [];
for p in self.particles:
newPosDist = self.getPositionDistribution(self.setGhostPosition(gameState, p));
newParticles.append(util.sampleFromCounter(newPosDist));
self.particles = newParticles;
def elapseTime(self, gameState):
"""
Update beliefs for a time step elapsing.
As in the elapseTime method of ExactInference, you should use:
newPosDist = self.getPositionDistribution(self.setGhostPosition(gameState, oldPos))
to obtain the distribution over new positions for the ghost, given
its previous position (oldPos) as well as Pacman's current
position.
"""
"*** YOUR CODE HERE ***"
for i in range(self.numParticles):
new_p_distr = self.getPositionDistribution(
self.setGhostPosition(gameState, self.particles[i]))
self.particles[i] = util.sampleFromCounter(new_p_distr)
# print( "update for time: ", self.particles )
return
def observeState(self, gameState, friendlyIndex):
"""
Resamples the set of particles using the likelihood of the noisy observations.
A correct implementation will handle two special cases:
1) When a ghost is captured by Pacman, all particles should be updated so
that the ghost appears in its cell, position (2 * ghostIndex - 1, 1).
Captured ghosts always have a noisyDistance of 999.
2) When all particles receive 0 weight, they should be recreated from the
prior distribution by calling initializeParticles.
"""
friendlyPosition = gameState.getAgentPosition(friendlyIndex) # Should NEVER be 'None'
noisyDistances = list()
#for i in range(gameState.getNumAgents()):
# print gameState.getAgentPosition(i)
for i in range(len(gameState.getAgentDistances())):
if i in self.enemyIndices:
noisyDistances.append(gameState.getAgentDistances()[i])
emissionModels = [getObservationDistribution(dist) for dist in noisyDistances]
particleWeightsCounter = util.Counter()
if (len(emissionModels) != 0):
for particleArray in self.particles:
particleArrayList = list(particleArray)
particle_weights = util.Counter()
for enemyIndex in range(self.numEnemy):
trueDist = util.manhattanDistance(friendlyPosition, particleArrayList[enemyIndex])
weight = (float) (emissionModels[enemyIndex][trueDist])
particle_weights[enemyIndex] += weight
weightProduct = 1
for particle in particle_weights:
weightProduct *= particle_weights[particle]
particleArrayList = tuple(particleArrayList)
particleWeightsCounter[particleArrayList] = weightProduct + particleWeightsCounter[particleArrayList]
if (sum(particleWeightsCounter.values()) == 0):
self.initializeParticles()
return
newParticles = []
for n in range(len(self.particles)):
resample = util.sampleFromCounter(particleWeightsCounter)
newParticles.append(resample)
self.particles = newParticles;
def elapseTime(self, gameState):
"""
Update beliefs for a time step elapsing.
As in the elapseTime method of ExactInference, you should use:
newPosDist = self.getPositionDistribution(self.setGhostPosition(gameState, oldPos))
to obtain the distribution over new positions for the ghost, given
its previous position (oldPos) as well as Pacman's current
position.
util.sample(Counter object) is a helper method to generate a sample from a
belief distribution
"""
"*** YOUR CODE HERE ***"
updatedParticlesList = []
for oldPosition in self.particles:
updatedPositionDistance = self.getPositionDistribution(self.setGhostPosition(gameState, oldPosition))
updatedParticlesList.append(util.sampleFromCounter(updatedPositionDistance))
self.particles = updatedParticlesList
def elapseTime(self, gameState):
"""
Update beliefs for a time step elapsing.
As in the elapseTime method of ExactInference, you should use:
newPosDist = self.getPositionDistribution(self.setGhostPosition(gameState, oldPos))
to obtain the distribution over new positions for the ghost, given its
previous position (oldPos) as well as Pacman's current position.
util.sample(Counter object) is a helper method to generate a sample from
a belief distribution.
"""
particles = self.particles
newParticles = []
for particle in particles:
newPosDist = self.getPositionDistribution(self.setGhostPosition(gameState, particle))
newParticle = util.sampleFromCounter(newPosDist)
newParticles.append(newParticle)
self.particles = newParticles
def elapseTime(self, gameState):
"""
Update beliefs for a time step elapsing.
As in the elapseTime method of ExactInference, you should use:
newPosDist = self.getPositionDistribution(self.setGhostPosition(gameState, oldPos))
to obtain the distribution over new positions for the ghost, given its
previous position (oldPos) as well as Pacman's current position.
util.sample(Counter object) is a helper method to generate a sample from
a belief distribution.
"""
"*** Q5 CODE STARTS HERE ***"
# util.raiseNotDefined()
listOfNewParticles = []
for posn in self.particles:
newParticlePos = self.getPositionDistribution(self.setGhostPosition(gameState, posn))
listOfNewParticles.append(util.sampleFromCounter(newParticlePos))
self.particles = listOfNewParticles
def observe(self, observation, gameState):
"Update beliefs based on the given distance observation."
emissionModel = busters.getObservationDistribution(observation)
pacmanPosition = gameState.getPacmanPosition()
particleWeights = util.Counter()
# Because the evidence itself is dependent on position;
# I am also resampling here.
for p in self.legalPositions:
# Noise - is it helping ?
particleWeights[p] = 1
particleWeights.normalize()
for p in self.particles:
trueDistance = util.manhattanDistance(p, pacmanPosition)
# Hardcoded : uggh. priority to current particles
particleWeights[p] += 10 * emissionModel[trueDistance]
particleWeights.normalize()
self.particles = []
#self.particleWeights = util.Counter()
for i in range(self.numParticles):
p = util.sampleFromCounter(particleWeights)
self.particles.append(p)
def observeState(self, gameState):
"""
Resamples the set of particles using the likelihood of the noisy observations.
As in elapseTime, to loop over the ghosts, use:
for i in range(self.numGhosts):
...
A correct implementation will handle two special cases:
1) When a ghost is captured by Pacman, all particles should be updated so
that the ghost appears in its prison cell, position self.getJailPosition(i)
where "i" is the index of the ghost.
You can check if a ghost has been captured by Pacman by
checking if it has a noisyDistance of None (a noisy distance
of None will be returned if, and only if, the ghost is
captured).
2) When all particles receive 0 weight, they should be recreated from the
prior distribution by calling initializeParticles. Remember to
change ghosts' positions to jail if called for.
"""
pacmanPosition = gameState.getPacmanPosition()
noisyDistances = gameState.getNoisyGhostDistances()
if len(noisyDistances) < self.numGhosts:
return
emissionModels = [busters.getObservationDistribution(dist) for dist in noisyDistances]
"*** YOUR CODE HERE ***"
allPossible = util.Counter()
value = 0
for p in range(self.numParticles):
accumulatedWeight = 1.0
for g in range(self.numGhosts):
if noisyDistances[g] == None:
continue
elif noisyDistances[g] != None:
pos = self.particles[p][g]
trueDistance = util.manhattanDistance(pos, pacmanPosition)
# if emissionModels[g][trueDistance] > 0:
value = 1
accumulatedWeight = accumulatedWeight * emissionModels[g][trueDistance]
# allPossible[p].normalize()
allPossible[self.particles[p]] = allPossible[self.particles[p]] + accumulatedWeight
allPossible.normalize()
self.particles = []
newParticles = []
# all weights for particles == 0
if value == 0:
self.initializeParticles()
else:
for i in range(self.numParticles):
samplePos = util.sampleFromCounter(allPossible)
# self.particles[samplePos] = self.particles[samplePos] + 1
self.particles.append(samplePos)
# Resample:
# Use the probability distribution from allPossible {Pos: probability, Pos: probability, ...}
# self.particles = util.Counter()
for p in self.particles:
p = list(p)
for g in range(self.numGhosts):
if noisyDistances[g] == None:
p[g] = self.getJailPosition(g)
newParticles.append(tuple(p))
self.particles = newParticles
"""
def observeState(self, gameState):
"""
Resamples the set of particles using the likelihood of the noisy observations.
As in elapseTime, to loop over the ghosts, use:
for i in range(self.numGhosts):
...
A correct implementation will handle two special cases:
1) When a ghost is captured by Pacman, all particles should be updated so
that the ghost appears in its prison cell, position self.getJailPosition(i)
where "i" is the index of the ghost.
You can check if a ghost has been captured by Pacman by
checking if it has a noisyDistance of None (a noisy distance
of None will be returned if, and only if, the ghost is
captured).
2) When all particles receive 0 weight, they should be recreated from the
prior distribution by calling initializeParticles. Remember to
change ghosts' positions to jail if called for.
"""
pacmanPosition = gameState.getPacmanPosition()
noisyDistances = gameState.getNoisyGhostDistances()
if len(noisyDistances) < self.numGhosts: return
emissionModels = [busters.getObservationDistribution(dist) for dist in noisyDistances]
"*** YOUR CODE HERE ***"
allPossible = util.Counter()
#new weights
for particle in self.particles:
#variables
pList = list(particle)
pweights = util.Counter()
weightProduct = 1
resampledParticles = []
for i in range(self.numGhosts):
if (noisyDistances[i] == 999):
pList[i] = (2 * (i+1) - 1, 1)
pweights[i] = 1.0
else:
weight = (float) (emissionModels[i][util.manhattanDistance(pacmanPosition, pList[i])])
pweights[i] += weight #multiple of the weights of each ghost
for particle in pweights:
weightProduct *= pweights[particle]
pList = tuple(pList) #initialized as a tuple
allPossible[pList] += weightProduct
if (sum(allPossible.values()) == 0):
self.initializeParticles()
return
#resampling with the new weights
for n in range(len(self.particles)):
resample = util.sampleFromCounter(allPossible)
resampledParticles.append(resample)
self.particles = resampledParticles
def observeState(self, gameState):
"""
Resamples the set of particles using the likelihood of the noisy
observations.
To loop over the ghosts, use:
for i in range(self.numGhosts):
...
A correct implementation will handle two special cases:
1) When a ghost is captured by Pacman, all particles should be updated
so that the ghost appears in its prison cell, position
self.getJailPosition(i) where `i` is the index of the ghost.
As before, you can check if a ghost has been captured by Pacman by
checking if it has a noisyDistance of None.
2) When all particles receive 0 weight, they should be recreated from
the prior distribution by calling initializeParticles. After all
particles are generated randomly, any ghosts that are eaten (have
noisyDistance of None) must be changed to the jail Position. This
will involve changing each particle if a ghost has been eaten.
self.getParticleWithGhostInJail is a helper method to edit a specific
particle. Since we store particles as tuples, they must be converted to
a list, edited, and then converted back to a tuple. This is a common
operation when placing a ghost in jail.
"""
pacmanPosition = gameState.getPacmanPosition()
noisyDistances = gameState.getNoisyGhostDistances()
if len(noisyDistances) < self.numGhosts:
return
emissionModels = [busters.getObservationDistribution(dist) for dist in noisyDistances]
"*** YOUR CODE HERE ***"
# here
# if noisyDistance is None:
# self.particles[p] = self.getParticleWithGhostInJail
# allPossible = util.Counter()
# for i in range(self.numGhosts):
# if allPossible.totalCount() == 0:
# self.initializeParticles()
# noneList = []
# for i in range(len(noisyDistances)):
# if noisyDistances[i] is None:
# noneList.append(i)
# allPossible = util.Counter()
# for i in range(len(self.particles)):
# p = self.particles[i]
# for j in noneList:
# p = self.getParticleWithGhostInJail(p,j)
# curr = 1
# for j in range(self.numGhosts):
# if noisyDistances[j] is not None:
# dist = util.manhattanDistance(p[j], pacmanPosition)
# curr *= emissionModels[j][dist]
# allPossible[p] += curr
# if allPossible.totalCount() != 0:
# self.particles = [util.sample(allPossible) for i in range(len(self.particles))]
# else:
# self.initializeParticles()
allPossible = util.Counter()
for particle in self.particles:
product = 1.0
for i in range(self.numGhosts):
if noisyDistances[i] is not None:
distance = util.manhattanDistance(particle[i], pacmanPosition)
product *= emissionModels[i][distance]
else:
particle = self.getParticleWithGhostInJail(particle, i)
allPossible[particle] += product
if allPossible.totalCount() == 0:
self.initializeParticles()
for particle in self.particles:
for i in range(self.numGhosts):
if noisyDistances[i] == None:
particle = self.getParticleWithGhostInJail(particle, i)
else:
dist = []
for particle in range(self.numParticles):
dist.append(util.sampleFromCounter(allPossible))
self.particles = dist
def observeState(self, gameState):
"""
Resamples the set of particles using the likelihood of the noisy
observations.
To loop over the ghosts, use:
for i in range(self.numGhosts):
...
A correct implementation will handle two special cases:
1) When a ghost is captured by Pacman, all particles should be updated
so that the ghost appears in its prison cell, position
self.getJailPosition(i) where `i` is the index of the ghost.
As before, you can check if a ghost has been captured by Pacman by
checking if it has a noisyDistance of None.
2) When all particles receive 0 weight, they should be recreated from
the prior distribution by calling initializeParticles. After all
particles are generated randomly, any ghosts that are eaten (have
noisyDistance of None) must be changed to the jail Position. This
will involve changing each particle if a ghost has been eaten.
self.getParticleWithGhostInJail is a helper method to edit a specific
particle. Since we store particles as tuples, they must be converted to
a list, edited, and then converted back to a tuple. This is a common
operation when placing a ghost in jail.
"""
pacmanPosition = gameState.getPacmanPosition()
noisyDistances = gameState.getNoisyGhostDistances()
if len(noisyDistances) < self.numGhosts:
return
emissionModels = [busters.getObservationDistribution(dist) for dist in noisyDistances]
"*** Q6 CODE STARTS HERE ***"
distribution = util.Counter()
beliefs = self.getBeliefDistribution()
for posn in self.particles:
particle = list(posn)
# print "particle :::: ", particle
particleWeight = 1
for i in range(self.numGhosts):
if not noisyDistances[i] is None:
distance = util.manhattanDistance(pacmanPosition, particle[i])
# particleWeight *= emissionModels[i][distance] * beliefs[i]
particleWeight *= emissionModels[i][distance]
distribution[tuple(posn)] += particleWeight
# distribution.normalize()
if sum(distribution.values()) == 0:
self.initializeParticles()
else:
particleList = []
for p in range(self.numParticles):
particle = []
for g in range(self.numGhosts):
if noisyDistances[g] is None:
# 5-JointParticleObserve.test failed as it returned tuple instead of list
# particle.append(self.getParticleWithGhostInJail(self.particles[p], g))
# particle.append((2*g + 1, 1))
particle.append(self.getJailPosition(g))
else:
sample = util.sampleFromCounter(distribution)
particle.append(sample[g])
particleList.append(tuple(particle))
self.particles = particleList
def observeState(self, gameState):
"""
Resamples the set of particles using the likelihood of the noisy
observations.
To loop over the ghosts, use:
for i in range(self.numGhosts):
...
A correct implementation will handle two special cases:
1) When a ghost is captured by Pacman, all particles should be updated
so that the ghost appears in its prison cell, position
self.getJailPosition(i) where `i` is the index of the ghost.
As before, you can check if a ghost has been captured by Pacman by
checking if it has a noisyDistance of None.
2) When all particles receive 0 weight, they should be recreated from
the prior distribution by calling initializeParticles. After all
particles are generated randomly, any ghosts that are eaten (have
noisyDistance of None) must be changed to the jail Position. This
will involve changing each particle if a ghost has been eaten.
self.getParticleWithGhostInJail is a helper method to edit a specific
particle. Since we store particles as tuples, they must be converted to
a list, edited, and then converted back to a tuple. This is a common
operation when placing a ghost in jail.
"""
pacmanPosition = gameState.getPacmanPosition()
noisyDistances = gameState.getNoisyGhostDistances()
if len(noisyDistances) < self.numGhosts:
return
emissionModels = [busters.getObservationDistribution(dist) for dist in noisyDistances]
"*** YOUR CODE HERE ***"
allPossible = util.Counter()
beliefs = self.getBeliefDistribution()
ghost = 0
totalWeights = 0
for nd in noisyDistances:
if nd == None:
for particle, prob in beliefs.items():
allPossible[self.getParticleWithGhostInJail(particle, ghost)] += prob
beliefs = allPossible
beliefs.normalize()
allPossible = util.Counter()
ghost += 1
for particle, prob in beliefs.items():
allPossible[particle] = prob
for ghost in range(0, self.numGhosts):
if noisyDistances[ghost] != None:
allPossible[particle] *= emissionModels[ghost][
util.manhattanDistance(particle[ghost], pacmanPosition)
]
beliefs = allPossible
beliefs.normalize()
for belief, prob in beliefs.items():
totalWeights += prob
if totalWeights != 0:
break
if totalWeights == 0:
self.initializeParticles()
else:
self.particles = list()
while len(self.particles) < self.numParticles:
self.particles.append(util.sampleFromCounter(beliefs))
def observeState(self, gameState):
"""
Resamples the set of particles using the likelihood of the noisy observations.
As in elapseTime, to loop over the ghosts, use:
for i in range(self.numGhosts):
...
A correct implementation will handle two special cases:
1) When a ghost is captured by Pacman, all particles should be updated so
that the ghost appears in its prison cell, position self.getJailPosition(i)
where "i" is the index of the ghost.
You can check if a ghost has been captured by Pacman by
checking if it has a noisyDistance of None (a noisy distance
of None will be returned if, and only if, the ghost is
captured).
2) When all particles receive 0 weight, they should be recreated from the
prior distribution by calling initializeParticles. Remember to
change ghosts' positions to jail if called for.
"""
'''
noisyDistance = observation
emissionModel = busters.getObservationDistribution(noisyDistance)
pacmanPosition = gameState.getPacmanPosition()
"*** YOUR CODE HERE ***"
POSITION, WEIGHT = 0, 1
if noisyDistance == None:
self.particles = [(self.getJailPosition(), 1) for _ in range(self.numParticles)]
else:
newParticles = []
for par in self.particles:
newPar = (par[POSITION], emissionModel[util.manhattanDistance(pacmanPosition, par[POSITION])])
newParticles.append(newPar)
newDistribution = util.Counter()
for p in self.legalPositions:
newDistribution[p] = sum([par[WEIGHT] for par in newParticles if par[POSITION] == p])
if len([p for p in self.legalPositions if newDistribution[p] > 0]) == 0:
self.initializeUniformly(gameState)
newDistribution = util.Counter()
for p in self.legalPositions:
newDistribution[p] = sum([par[WEIGHT] for par in newParticles if par[POSITION] == p])
else:
self.particles = [(util.sampleFromCounter(newDistribution), 1) for _ in range(self.numParticles)]
'''
pacmanPosition = gameState.getPacmanPosition()
noisyDistances = gameState.getNoisyGhostDistances()
if len(noisyDistances) < self.numGhosts: return
emissionModels = [busters.getObservationDistribution(dist) for dist in noisyDistances]
"*** YOUR CODE HERE ***"
WEIGHT = -1
#validGhostIndices = range(self.numGhosts)
#for i in validGhostIndices:
# if noisyDistances[i] == None:
# validGhostIndices.remove(i)
self.particles = self.sendToJail(noisyDistances)
newParticles = []
for par in self.particles:
newParticle = list(par)
#print [emissionModels[i][util.manhattanDistance(pacmanPosition, newParticle[i])]
# for i in range(len(emissionModels)) if newParticle[i] != self.getJailPosition(i)]
newParticle[WEIGHT] = reduce(mul, [emissionModels[i][util.manhattanDistance(pacmanPosition, newParticle[i])]
for i in range(len(emissionModels)) if noisyDistances[i] != None])
newParticles.append(tuple(newParticle))
newDistribution = util.Counter()
for par in newParticles:
newDistribution[par[:WEIGHT]] = sum(newParticle[WEIGHT] for newParticle in newParticles if newParticle[:WEIGHT] == par[:WEIGHT])
#print "Number of nonzero-weight particles:", len([par for par in newParticles if newDistribution[par[:WEIGHT]] > 0])
if len([par for par in newParticles if newDistribution[par[:WEIGHT]] > 0]) == 0:
#print "Need to re-initialize"
self.initializeParticles()
self.particles = self.sendToJail(noisyDistances)
newDistribution = util.Counter()
for par in self.particles:
newDistribution[par[:WEIGHT]] = sum(newParticle[WEIGHT] for newParticle in self.particles if newParticle[:WEIGHT] == par[:WEIGHT])
else:
#print "Everything is fine here"
self.particles = [tuple(list(util.sampleFromCounter(newDistribution)) + [1]) for _ in range(self.numParticles)]
