code: def inferObjectsWithRandomMovements(self, objectPlacements, maxTouches=20,
                                        settlingTime=2):
      
  
      for monitor in self.monitors.values():
        monitor.afterPlaceObjects(objectPlacements)
  
      for objectName, objectDict in self.objects.iteritems():
        self.reset()
  
        visitCounts = defaultdict(int)
  
        learnedObjectPlacement = self.learnedObjectPlacements[objectName]
  
        allocentricLocation = random.choice(objectDict.keys())
        nextTransitionSDR = np.empty(0, dtype="uint32")
  
        # Traverse the object until it is inferred.
        success = False
  
        for _ in xrange(maxTouches):
          featureName = objectDict[allocentricLocation]
          egocentricLocation = (allocentricLocation[0] +
                                objectPlacements[objectName][0],
                                allocentricLocation[1] +
                                objectPlacements[objectName][1])
          featureSDR = self.features[featureName]
  
          steps = ([nextTransitionSDR] +
                   [np.empty(0)]*settlingTime)
          for transitionSDR in steps:
            self.doTimestep(np.empty(0), transitionSDR, featureSDR,
                            egocentricLocation, learn=False)
  
          visitCounts[allocentricLocation] += 1
  
          # We should eventually infer the egocentric location where we originally
          # learned this location on the object.
          learnedEgocentricLocation = (
            allocentricLocation[0] + learnedObjectPlacement[0],
            allocentricLocation[1] + learnedObjectPlacement[1])
  
          if (set(self.objectLayer.getActiveCells()) ==
              set(self.objectRepresentations[objectName]) and
  
              set(self.inputLayer.getActiveCells()) ==
              set(self.inputRepresentations[(featureName,
                                             learnedEgocentricLocation)]) and
  
              set(self.locationLayer.getActiveCells()) ==
              set(self.locations[learnedEgocentricLocation])):
            success = True
            break
          else:
            allocentricLocation, transitionName = self._selectTransition(
              allocentricLocation, objectDict, visitCounts)
            nextTransitionSDR = self.transitions[transitionName]
docs: Infer each object without any location input.