我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用util.Counter()。
def displayDistributionsOverPositions(self, distributions): """ Overlays a distribution over positions onto the pacman board that represents an agent's beliefs about the positions of each agent. The arg distributions is a tuple or list of util.Counter objects, where the i'th Counter has keys that are board positions (x,y) and values that encode the probability that agent i is at (x,y). If some elements are None, then they will be ignored. If a Counter is passed to this function, it will be displayed. This is helpful for figuring out if your agent is doing inference correctly, and does not affect gameplay. """ dists = [] for dist in distributions: if dist != None: if not isinstance(dist, util.Counter): raise Exception("Wrong type of distribution") dists.append(dist) else: dists.append(util.Counter()) if self.display != None and 'updateDistributions' in dir(self.display): self.display.updateDistributions(dists) else: self._distributions = dists # These can be read by pacclient.py
def getFeatures(self, gameState, action): features = util.Counter() successor = self.getSuccessor(gameState, action) myState = successor.getAgentState(self.index) myPos = myState.getPosition() # Computes whether we're on defense (1) or offense (0) features['onDefense'] = 1 if myState.isPacman: features['onDefense'] = 0 # Computes distance to invaders we can see enemies = [successor.getAgentState(i) for i in self.getOpponents(successor)] invaders = [a for a in enemies if a.isPacman and a.getPosition() != None] features['numInvaders'] = len(invaders) if len(invaders) > 0: dists = [self.getMazeDistance(myPos, a.getPosition()) for a in invaders] features['invaderDistance'] = min(dists) if action == Directions.STOP: features['stop'] = 1 rev = Directions.REVERSE[gameState.getAgentState(self.index).configuration.direction] if action == rev: features['reverse'] = 1 return features
def getFeatures(self,state,action): feats = util.Counter() handcard = list(state) handcard.remove(action) handSet = set(handcard) feats['???'] = len(handcard) feats['?'] = len([ card for card in handSet if handcard.count(card) == 2]) feats['?'] = len([ card for card in handSet if handcard.count(card) == 3]) feats['?'] = len([ card for card in handSet if handcard.count(card) == 4]) for card in handSet : if int(card/10) < 3 and card % 10 != 0: if card %10 < 8 and (card+1 in handSet) and (card+2 in handSet): feats['?'] += 1 return feats
def __init__(self, mdp, discount = 0.9, iterations = 100): """ Your value iteration agent should take an mdp on construction, run the indicated number of iterations and then act according to the resulting policy. Some useful mdp methods you will use: mdp.getStates() mdp.getPossibleActions(state) mdp.getTransitionStatesAndProbs(state, action) mdp.getReward(state, action, nextState) """ self.mdp = mdp self.discount = discount self.iterations = iterations self.values = util.Counter() # A Counter is a dict with default 0 "*** YOUR CODE HERE ***"
def enhancedFeatureExtractorDigit(datum): """ Your feature extraction playground. You should return a util.Counter() of features for this datum (datum is of type samples.Datum). ## DESCRIBE YOUR ENHANCED FEATURES HERE... ## """ features = basicFeatureExtractorDigit(datum) for x in range(DIGIT_DATUM_WIDTH): for y in range(DIGIT_DATUM_HEIGHT): if (datum.getPixel(x, y) > datum.getPixel(x, y - 1) ): features[(x, y, 0)] = 1 else: features[(x, y, 0)] = 0 return features
def basicFeatureExtractorPacman(state): """ A basic feature extraction function. You should return a util.Counter() of features for each (state, action) pair along with a list of the legal actions ## """ features = util.Counter() for action in state.getLegalActions(): successor = state.generateSuccessor(0, action) foodCount = successor.getFood().count() featureCounter = util.Counter() featureCounter['foodCount'] = foodCount features[action] = featureCounter return features, state.getLegalActions()
def findHighWeightFeatures(self, label): """ Returns a list of the 100 features with the greatest weight for some label """ featuresWeights = [] sorted_dict = util.Counter() sorted_dict = self.weights[label] sorted_dict = sorted_dict.sortedKeys() temp = 0 for key in sorted_dict: featuresWeights.append(key) temp = temp + 1 if temp > 99: break return featuresWeights
def __init__(self, mdp, discount = 0.9, iterations = 100): """ Your value iteration agent should take an mdp on construction, run the indicated number of iterations and then act according to the resulting policy. Some useful mdp methods you will use: mdp.getStates() mdp.getPossibleActions(state) mdp.getTransitionStatesAndProbs(state, action) mdp.getReward(state, action, nextState) mdp.isTerminal(state) """ self.mdp = mdp self.discount = discount self.iterations = iterations self.values = util.Counter() # A Counter is a dict with default 0 # Write value iteration code here "*** YOUR CODE HERE ***"
def fit(self, trainingData, trainingLabels): """ Trains the classifier by collecting counts over the training data, and stores the Laplace smoothed estimates so that they can be used to classify. trainingData is a list of feature dictionaries. The corresponding label lists contain the correct label for each instance. To get the list of all possible features or labels, use self.features and self.legalLabels. """ self.features = trainingData[0].keys() # the names of the features in the dataset self.prior = util.Counter() # probability over labels self.conditionalProb = util.Counter() # Conditional probability of feature feat for a given class having value v # HINT: could be indexed by (feat, label, value) # TODO: # construct (and store) the normalized smoothed priors and conditional probabilities "*** YOUR CODE HERE ***"
def calculateLogJointProbabilities(self, instance): """ Returns the log-joint distribution over legal labels and the instance. Each log-probability should be stored in the log-joint counter, e.g. logJoint[3] = <Estimate of log( P(Label = 3, instance) )> To get the list of all possible features or labels, use self.features and self.legalLabels. """ logJoint = util.Counter() for label in self.legalLabels: #calculate the log joint probabilities for each class "*** YOUR CODE HERE ***" pass return logJoint
def getFeatures(self, gameState, action): """ Returns a counter of features for the state """ features = util.Counter() successor = self.getSuccessor(gameState, action) features['successorScore'] = self.getScore(successor) return features
def getFeatures(self, gameState, action): features = util.Counter() successor = self.getSuccessor(gameState, action) foodList = self.getFood(successor).asList() features['successorScore'] = -len(foodList)#self.getScore(successor) # Compute distance to the nearest food if len(foodList) > 0: # This should always be True, but better safe than sorry myPos = successor.getAgentState(self.index).getPosition() minDistance = min([self.getMazeDistance(myPos, food) for food in foodList]) features['distanceToFood'] = minDistance return features
def getDistribution(self, state): "Returns a Counter encoding a distribution over actions from the provided state." util.raiseNotDefined()
def getDistribution( self, state ): dist = util.Counter() for a in state.getLegalActions( self.index ): dist[a] = 1.0 dist.normalize() return dist
def getDistribution( self, state ): # Read variables from state ghostState = state.getGhostState( self.index ) legalActions = state.getLegalActions( self.index ) pos = state.getGhostPosition( self.index ) isScared = ghostState.scaredTimer > 0 speed = 1 if isScared: speed = 0.5 actionVectors = [Actions.directionToVector( a, speed ) for a in legalActions] newPositions = [( pos[0]+a[0], pos[1]+a[1] ) for a in actionVectors] pacmanPosition = state.getPacmanPosition() # Select best actions given the state distancesToPacman = [manhattanDistance( pos, pacmanPosition ) for pos in newPositions] if isScared: bestScore = max( distancesToPacman ) bestProb = self.prob_scaredFlee else: bestScore = min( distancesToPacman ) bestProb = self.prob_attack bestActions = [action for action, distance in zip( legalActions, distancesToPacman ) if distance == bestScore] # Construct distribution dist = util.Counter() for a in bestActions: dist[a] = bestProb / len(bestActions) for a in legalActions: dist[a] += ( 1-bestProb ) / len(legalActions) dist.normalize() return dist
def getFeatures(self, gameState, action): features = util.Counter() successor = self.getSuccessor(gameState, action) myState = successor.getAgentState(self.index) myPos = myState.getPosition() # Computes whether we're on defense (1) or offense (0) features['onDefense'] = 1 # the line below prevent ghost become pacman, can lose the tie. if myState.isPacman: features['onDefense'] = 0 # Computes distance to invaders we can see enemies = [successor.getAgentState(i) for i in self.getOpponents(successor)] invaders = [a for a in enemies if a.isPacman and a.getPosition() != None] features['numInvaders'] = len(invaders) if len(invaders) > 0: dists = [self.getMazeDistance(myPos, a.getPosition()) for a in invaders] # for a in invaders: # print "Ghost position", a.getPosition(), "MyPosition: ", myPos # features['invaderDistance'] = min(dists) if action == Directions.STOP: features['stop'] = 1 rev = Directions.REVERSE[gameState.getAgentState(self.index).configuration.direction] if action == rev: features['reverse'] = 1 return features
def setLearningTarget(self): self.qValues = util.Counter()
def setLearningTarget(self): self.weights = util.Counter()
def displayValues(self, agent, currentState = None, message = None): if message != None: print message values = util.Counter() policy = {} states = self.gridworld.getStates() for state in states: values[state] = agent.getValue(state) policy[state] = agent.getPolicy(state) prettyPrintValues(self.gridworld, values, policy, currentState)
def displayQValues(self, agent, currentState = None, message = None): if message != None: print message qValues = util.Counter() states = self.gridworld.getStates() for state in states: for action in self.gridworld.getPossibleActions(state): qValues[(state, action)] = agent.getQValue(state, action) prettyPrintQValues(self.gridworld, qValues, currentState)
def getFeatures(self, state, action): feats = util.Counter() feats[(state,action)] = 1.0 return feats
def getFeatures(self, state, action): # extract the grid of food and wall locations and get the ghost locations food = state.getFood() walls = state.getWalls() ghosts = state.getGhostPositions() features = util.Counter() features["bias"] = 1.0 # compute the location of pacman after he takes the action x, y = state.getPacmanPosition() dx, dy = Actions.directionToVector(action) next_x, next_y = int(x + dx), int(y + dy) # count the number of ghosts 1-step away features["#-of-ghosts-1-step-away"] = sum((next_x, next_y) in Actions.getLegalNeighbors(g, walls) for g in ghosts) # if there is no danger of ghosts then add the food feature if not features["#-of-ghosts-1-step-away"] and food[next_x][next_y]: features["eats-food"] = 1.0 dist = closestFood((next_x, next_y), food, walls) if dist is not None: # make the distance a number less than one otherwise the update # will diverge wildly features["closest-food"] = float(dist) / (walls.width * walls.height) features.divideAll(10.0) return features
def displayValues(self, agent, currentState = None, message = 'Agent Values'): values = util.Counter() policy = {} states = self.gridworld.getStates() for state in states: values[state] = agent.getValue(state) policy[state] = agent.getPolicy(state) drawValues(self.gridworld, values, policy, currentState, message) sleep(0.05 / self.speed)
def displayNullValues(self, currentState = None, message = ''): values = util.Counter() #policy = {} states = self.gridworld.getStates() for state in states: values[state] = 0.0 #policy[state] = agent.getPolicy(state) drawNullValues(self.gridworld, currentState,'') # drawValues(self.gridworld, values, policy, currentState, message) sleep(0.05 / self.speed)
def displayQValues(self, agent, currentState = None, message = 'Agent Q-Values'): qValues = util.Counter() states = self.gridworld.getStates() for state in states: for action in self.gridworld.getPossibleActions(state): qValues[(state, action)] = agent.getQValue(state, action) drawQValues(self.gridworld, qValues, currentState, message) sleep(0.05 / self.speed)
def drawQValues(gridworld, qValues, currentState = None, message = 'State-Action Q-Values'): grid = gridworld.grid blank() stateCrossActions = [[(state, action) for action in gridworld.getPossibleActions(state)] for state in gridworld.getStates()] qStates = reduce(lambda x,y: x+y, stateCrossActions, []) qValueList = [qValues[(state, action)] for state, action in qStates] + [0.0] minValue = min(qValueList) maxValue = max(qValueList) for x in range(grid.width): for y in range(grid.height): state = (x, y) gridType = grid[x][y] isExit = (str(gridType) != gridType) isCurrent = (currentState == state) actions = gridworld.getPossibleActions(state) if actions == None or len(actions) == 0: actions = [None] bestQ = max([qValues[(state, action)] for action in actions]) bestActions = [action for action in actions if qValues[(state, action)] == bestQ] q = util.Counter() valStrings = {} for action in actions: v = qValues[(state, action)] q[action] += v valStrings[action] = '%.2f' % v if gridType == '#': drawSquare(x, y, 0, 0, 0, None, None, True, False, isCurrent) elif isExit: action = 'exit' value = q[action] valString = '%.2f' % value drawSquare(x, y, value, minValue, maxValue, valString, action, False, isExit, isCurrent) else: drawSquareQ(x, y, q, minValue, maxValue, valStrings, actions, isCurrent) pos = to_screen(((grid.width - 1.0) / 2.0, - 0.8)) text( pos, TEXT_COLOR, message, "Courier", -32, "bold", "c")
def __init__(self, **args): "You can initialize Q-values here..." ReinforcementAgent.__init__(self, **args) self.Qvalues = util.Counter()
def __init__(self, mdp, discount = 0.9, iterations = 100): """ Your value iteration agent should take an mdp on construction, run the indicated number of iterations and then act according to the resulting policy. Some useful mdp methods you will use: mdp.getStates() mdp.getPossibleActions(state) mdp.getTransitionStatesAndProbs(state, action) mdp.getReward(state, action, nextState) mdp.isTerminal(state) """ self.mdp = mdp self.discount = discount self.iterations = iterations self.values = util.Counter() # A Counter is a dict with default 0 self.actions = {} for _ in range(iterations): new_stateValues = {} new_actionValue = {} for state in self.mdp.getStates(): qvalue_list = [] possible_actions = mdp.getPossibleActions(state) if (len(possible_actions) == 0): new_stateValues[state] = 0 new_actionValue[state] = None else: for action in possible_actions: qvalue_list.append((self.getQValue(state,action),action)) vvalue = max(qvalue_list) new_stateValues[state] = vvalue[0] new_actionValue[state] = vvalue[1] self.values = new_stateValues self.actions = new_actionValue
def basicFeatureExtractorDigit(datum): """ Returns a set of pixel features indicating whether each pixel in the provided datum is white (0) or gray/black (1) """ a = datum.getPixels() features = util.Counter() for x in range(DIGIT_DATUM_WIDTH): for y in range(DIGIT_DATUM_HEIGHT): if datum.getPixel(x, y) > 0: features[(x,y)] = 1 else: features[(x,y)] = 0 return features
def basicFeatureExtractorFace(datum): """ Returns a set of pixel features indicating whether each pixel in the provided datum is an edge (1) or no edge (0) """ a = datum.getPixels() features = util.Counter() for x in range(FACE_DATUM_WIDTH): for y in range(FACE_DATUM_HEIGHT): if datum.getPixel(x, y) > 0: features[(x,y)] = 1 else: features[(x,y)] = 0 return features
def enhancedPacmanFeatures(state, action): """ For each state, this function is called with each legal action. It should return a counter with { <feature name> : <feature value>, ... } """ features = util.Counter() "*** YOUR CODE HERE ***" util.raiseNotDefined() return features
def analysis(classifier, guesses, testLabels, testData, rawTestData, printImage): """ This function is called after learning. Include any code that you want here to help you analyze your results. Use the printImage(<list of pixels>) function to visualize features. An example of use has been given to you. - classifier is the trained classifier - guesses is the list of labels predicted by your classifier on the test set - testLabels is the list of true labels - testData is the list of training datapoints (as util.Counter of features) - rawTestData is the list of training datapoints (as samples.Datum) - printImage is a method to visualize the features (see its use in the odds ratio part in runClassifier method) This code won't be evaluated. It is for your own optional use (and you can modify the signature if you want). """ # Put any code here... # Example of use: # for i in range(len(guesses)): # prediction = guesses[i] # truth = testLabels[i] # if (prediction != truth): # print "===================================" # print "Mistake on example %d" % i # print "Predicted %d; truth is %d" % (prediction, truth) # print "Image: " # print rawTestData[i] # break ## ===================== ## You don't have to modify any code below. ## =====================
def __init__( self, legalLabels, max_iterations): self.legalLabels = legalLabels self.type = "perceptron" self.max_iterations = max_iterations self.weights = {} for label in legalLabels: self.weights[label] = util.Counter() # this is the data-structure you should use
