Python BaseExplorer.first方法代码示例

# 需要导入模块: from nupic.vision.regions.ImageSensorExplorers.BaseExplorer import BaseExplorer [as 别名]
# 或者: from nupic.vision.regions.ImageSensorExplorers.BaseExplorer.BaseExplorer import first [as 别名]
  def first(self):
    """
    Set up the position.

    BaseExplorer picks image 0, offset (0,0), etc., but explorers that wish
    to set a different first position should extend this method. Such explorers
    may wish to call BaseExplorer.first(center=False), which initializes the
    position tuple but does not call centerImage() (which could cause
    unnecessary filtering to occur).
    """

    BaseExplorer.first(self)

    if not self.numImages:
      return

    # Set up the list of filenames
    self.names = []
    for i in xrange(self.numImages):
      path, filename = os.path.split(self.getImageInfo(i)['imagePath'])
      name = os.path.join(os.path.split(path)[1], filename)
      self.names.append(name)

    # Find the first image with some fixation points
    image = 0
    while not self.names[image] in self.points:
      # No fixation points for this image
      image += 1
      if image >= self.numImages:
        raise RuntimeError("No fixation points for any loaded images")
    self.position['image'] = image
    self._firstPoint()
    self.position['reset'] = True

# 需要导入模块: from nupic.vision.regions.ImageSensorExplorers.BaseExplorer import BaseExplorer [as 别名]
# 或者: from nupic.vision.regions.ImageSensorExplorers.BaseExplorer.BaseExplorer import first [as 别名]
  def first(self):
    """
    Set up the position.

    BaseExplorer picks image 0, offset (0,0), etc., but explorers that wish
    to set a different first position should extend this method. Such explorers
    may wish to call BaseExplorer.first(center=False), which initializes the
    position tuple but does not call centerImage() (which could cause
    unnecessary filtering to occur).
    """

    BaseExplorer.first(self, center=True)

    # Update the "home" position for the current image
    self._getHomePosition()

    if self._verbosity >= 1:
      print "BlockSpread: first():"

    # Set start position
    self._centerPosIdx = 0       # Which center point
    self._spreadPosIdx = 0       # radial position around the center point

    # Convert to X and Y offsets
    self._getPosition()

# 需要导入模块: from nupic.vision.regions.ImageSensorExplorers.BaseExplorer import BaseExplorer [as 别名]
# 或者: from nupic.vision.regions.ImageSensorExplorers.BaseExplorer.BaseExplorer import first [as 别名]
  def first(self):
    """
    Set up the position.

    BaseExplorer picks image 0, offset (0,0), etc., but explorers that wish
    to set a different first position should extend this method. Such explorers
    may wish to call BaseExplorer.first(center=False), which initializes the
    position tuple but does not call centerImage() (which could cause
    unnecessary filtering to occur).
    """

    BaseExplorer.first(self, center=False)

    if not self.numImages:
      return

    isBlank = True
    while isBlank:

      # Pick a random position
      if not self.numJumpsPerImage or self.lastImageIndex is None or \
          (self.numJumpsThisImage % self.numJumpsPerImage == 0):
        # Pick new image
        image = self.pickRandomImage(self.random)
        self.lastImageIndex = image
        self.numJumpsThisImage = 0
      else:
        image = self.lastImageIndex
      self.position['image'] = image
      self.position['filters'] = self.pickRandomFilters(self.random)
      filteredImages = self.getFilteredImages()

      # Pick a random offset
      if self.spaceShape is not None:
        self.centerImage()
        # NOTE: self.position['offset'] is (x, y), whereas our spaceShape is
        #  (height, width). Also note that the self.position['offset']
        #  direction is counter-intuitive: negative numbers move us to the RIGHT
        #  and DOWN instead of LEFT and UP.
        xOffset = self.random.randint(-(self.spaceShape[1]//2), self.spaceShape[1]//2)
        yOffset = self.random.randint(-(self.spaceShape[0]//2), self.spaceShape[0]//2)
        #print "(yOffset, xOffset) = ", yOffset, xOffset
        self.position['offset'][0] += xOffset
        self.position['offset'][1] += yOffset

      else:
        ebbox = self._getEffectiveBoundingBox(filteredImages[0])
        self.position['offset'] = [
          self.random.randint(ebbox[0], ebbox[2]-1),
          self.random.randint(ebbox[1], ebbox[3]-1)
        ]

      # Check if the position is blank
      isBlank = self.isBlank(self.jumpOffObject)

    self.position['reset'] = True
    self.numJumpsThisImage += 1

# 需要导入模块: from nupic.vision.regions.ImageSensorExplorers.BaseExplorer import BaseExplorer [as 别名]
# 或者: from nupic.vision.regions.ImageSensorExplorers.BaseExplorer.BaseExplorer import first [as 别名]
  def first(self):
    """
    Set up the position.

    BaseExplorer picks image 0, offset (0,0), etc., but explorers that wish
    to set a different first position should extend this method. Such explorers
    may wish to call BaseExplorer.first(center=False), which initializes the
    position tuple but does not call centerImage() (which could cause
    unnecessary filtering to occur).
    """
    BaseExplorer.first(self, center=False)
    self._computeNextPosn()

# 需要导入模块: from nupic.vision.regions.ImageSensorExplorers.BaseExplorer import BaseExplorer [as 别名]
# 或者: from nupic.vision.regions.ImageSensorExplorers.BaseExplorer.BaseExplorer import first [as 别名]
  def first(self, seeking=False):
    """Used in initialization of ImageSensor.
    Basic setup for running sequential saccades on random images.

    :param seeking: If True, don't do unnecessary computations
    """
    if not self.numImages:
      return

    self.history = []
    self.imageHistory = []

    BaseExplorer.first(self)
    self.prevSaccade = None
    self.position["image"] = self.pickRandomImage(self.random)
    self.saccadeIndex = 0

# 需要导入模块: from nupic.vision.regions.ImageSensorExplorers.BaseExplorer import BaseExplorer [as 别名]
# 或者: from nupic.vision.regions.ImageSensorExplorers.BaseExplorer.BaseExplorer import first [as 别名]
  def first(self):
    """
    Set up the position.

    BaseExplorer picks image 0, offset (0,0), etc., but explorers that wish
    to set a different first position should extend this method. Such explorers
    may wish to call BaseExplorer.first(center=False), which initializes the
    position tuple but does not call centerImage() (which could cause
    unnecessary filtering to occur).
    """

    BaseExplorer.first(self)

    self.diagdiri = 0
    self.diagi = 0
    self.position['offset'][0] += self.numSteps
    self.cent = list(self.position['offset'])
    self.jitteri = 0

# 需要导入模块: from nupic.vision.regions.ImageSensorExplorers.BaseExplorer import BaseExplorer [as 别名]
# 或者: from nupic.vision.regions.ImageSensorExplorers.BaseExplorer.BaseExplorer import first [as 别名]
  def first(self, center=True):
    """
    Set up the position.

    BaseExplorer picks image 0, offset (0,0), etc., but explorers that wish
    to set a different first position should extend this method. Such explorers
    may wish to call BaseExplorer.first(center=False), which initializes the
    position tuple but does not call centerImage() (which could cause
    unnecessary filtering to occur).
    """

    BaseExplorer.first(self, center)
    self._resetIndex()

    offsets = self._getCurrentOffsets()
    # Set the 2 dimensions of the position.
    for i in (0,1):
      self.position['offset'][i] = offsets[self.index][i]

# 需要导入模块: from nupic.vision.regions.ImageSensorExplorers.BaseExplorer import BaseExplorer [as 别名]
# 或者: from nupic.vision.regions.ImageSensorExplorers.BaseExplorer.BaseExplorer import first [as 别名]
  def first(self):
    """
    Set up the position.

    BaseExplorer picks image 0, offset (0,0), etc., but explorers that wish
    to set a different first position should extend this method. Such explorers
    may wish to call BaseExplorer.first(center=False), which initializes the
    position tuple but does not call centerImage() (which could cause
    unnecessary filtering to occur).
    """

    BaseExplorer.first(self)

    if not self.numImages:
      return

    if not self.replacement \
        and len(self.history) == self.getNumIterations(None):
      # All images have been visited
      self.history = []

    while True:
      self.position['image'] = self.pickRandomImage(self.random)
      self.position['filters'] = self.pickRandomFilters(self.random)
      index = self.random.randint(0, 8)
      historyItem = (self.position['image'], self.position['filters'][:], index)
      if self.replacement or historyItem not in self.history:
        # Use this position
        if not self.replacement:
          # Add to the history
          self.history.append(historyItem)
        # Calculate the offset from the eye movement index
        if index in (1, 2, 3):
          self.position['offset'][1] -= self.shift
        elif index in (5, 6, 7):
          self.position['offset'][1] += self.shift
        if index in (1, 7, 8):
          self.position['offset'][0] -= self.shift
        elif index in (3, 4, 5):
          self.position['offset'][0] += self.shift
        break

    self.position['reset'] = True

# 需要导入模块: from nupic.vision.regions.ImageSensorExplorers.BaseExplorer import BaseExplorer [as 别名]
# 或者: from nupic.vision.regions.ImageSensorExplorers.BaseExplorer.BaseExplorer import first [as 别名]
  def first(self):
    """
    Set up the position.

    BaseExplorer picks image 0, offset (0,0), etc., but explorers that wish
    to set a different first position should extend this method. Such explorers
    may wish to call BaseExplorer.first(center=False), which initializes the
    position tuple but does not call centerImage() (which could cause
    unnecessary filtering to occur).
    """

    BaseExplorer.first(self, center=False)

    if not self.numImages:
      return

    # Pick a random dimension (exclude filters without multiple outputs)
    filters = []
    for i in xrange(self.numFilters):
      if self.numFilterOutputs[i] > 1:
        filters.append(i)
    legalDimensions = self.dimensions[:]
    for d in self.dimensions:
      if type(d['name']) is int and d['name'] not in filters:
        legalDimensions.remove(d)
    # Choice is weighted by probabilities
    r = self.random.uniform(0, sum([d['probability'] for d in legalDimensions]))
    for i, d in enumerate(legalDimensions):
      if r <= d['probability']:
        self.dimension = d
        break
      r -= d['probability']

    self.start = None
    restart = True
    while restart:

      self.position['reset'] = False
      restart = False

      # Translation sweep
      if self.dimension['name'] == 'translation':

        # Pick a random direction, image, and set of filters
        self.direction = self.random.choice(('left', 'right', 'up', 'down',
          'leftdown', 'leftup', 'rightdown', 'rightup'))
        self.position['image'] = self.pickRandomImage(self.random)
        self.position['filters'] = self.pickRandomFilters(self.random)
        filteredImages = self.getFilteredImages()
        ebbox = self._getEffectiveBoundingBox(filteredImages[0])

        # Align starting position at zero offset position.
        forceAlignment = self.dimension.get('forceAlignment')
        if forceAlignment is not None and forceAlignment:
          self.position['offset'] = [0,0]
        # Pick a random starting position on the appropriate edge of the image
        else:
          self._firstTranslationPosition(ebbox, filteredImages[0])

        # Increment the start position until it is not blank
        while self.isBlank(self.dimension['sweepOffObject']):
          self._nextTranslationPosition(shift=1)
          if self.position['reset'] or not self.isValid():
            restart = True
            break
        if restart:
          continue

        # Increment the position by a random amount in the range [0, shift)
        if not forceAlignment:
          self._nextTranslationPosition(randomShift=True)

      # Image sweep
      elif self.dimension['name'] == 'image':

        # Pick a random direction
        self.direction = self.random.choice(('up', 'down'))

        # Pick a random image and find the first or last image in the category
        image = self.pickRandomImage(self.random)
        startCategory = self.getImageInfo(image)['categoryIndex']
        if self.direction == 'up':
          while image > 0 and \
              self.getImageInfo(image-1)['categoryIndex'] == startCategory:
            image -= 1
        else:
          while image < self.numImages - 1 and \
              self.getImageInfo(image+1)['categoryIndex'] == startCategory:
            image += 1
        self.position['image'] = image

        # Pick the filters
        self.position['filters'] = self.pickRandomFilters(self.random)
        filteredImages = self.getFilteredImages()

        # Pick a random position within the bounding box
        ebbox = self._getEffectiveBoundingBox(filteredImages[0])
        self.position['offset'] = [
          self.random.randint(ebbox[0], ebbox[2]-1),
          self.random.randint(ebbox[1], ebbox[3]-1)
#.........这里部分代码省略.........

# 需要导入模块: from nupic.vision.regions.ImageSensorExplorers.BaseExplorer import BaseExplorer [as 别名]
# 或者: from nupic.vision.regions.ImageSensorExplorers.BaseExplorer.BaseExplorer import first [as 别名]
  def first(self):
    """
    Set up the position.

    BaseExplorer picks image 0, offset (0,0), etc., but explorers that wish
    to set a different first position should extend this method. Such explorers
    may wish to call BaseExplorer.first(center=False), which initializes the
    position tuple but does not call centerImage() (which could cause
    unnecessary filtering to occur).
    """

    BaseExplorer.first(self, center=False)

    if not self.numImages:
      return

    # Pick a random direction and filtered image
    self.direction = self.random.choice(self.sweepDirections)
    self.position['image'] = self.random.randint(0, self.numImages - 1)
    for i in xrange(self.numFilters):
      self.position['filters'][i] = self.random.randint(0,
        self.numFilterOutputs[i] - 1)
    filteredImages = self.getFilteredImages()

    # Pick a random starting position on the appropriate edge of the image
    sbbox = self._getSweepBoundingBox(filteredImages[0])

    if self.direction == 'left':
      self.position['offset'][0] = sbbox[2] - 1
      self.position['offset'][1] = self.random.randint(sbbox[1], sbbox[3] - 1)
    elif self.direction == 'right':
      self.position['offset'][0] = sbbox[0]
      self.position['offset'][1] = self.random.randint(sbbox[1], sbbox[3] - 1)
    elif self.direction == 'up':
      self.position['offset'][0] = self.random.randint(sbbox[0], sbbox[2] - 1)
      self.position['offset'][1] = sbbox[3] - 1
    elif self.direction == 'down':
      self.position['offset'][0] = self.random.randint(sbbox[0], sbbox[2] - 1)
      self.position['offset'][1] = sbbox[1]
    elif self.direction in ('leftup', 'upleft'):
      if self.random.randint(0,1):
        self.position['offset'][0] = \
          self.random.randint(sbbox[0] + (sbbox[2] - sbbox[0])/2, sbbox[2] - 1)
        self.position['offset'][1] = sbbox[3] - 1
      else:
        self.position['offset'][0] = sbbox[2] - 1
        self.position['offset'][1] = \
          self.random.randint(sbbox[1] + (sbbox[3] - sbbox[1])/2, sbbox[3] - 1)
    elif self.direction in ('leftdown', 'downleft'):
      if self.random.randint(0,1):
        self.position['offset'][0] = \
          self.random.randint(sbbox[0] + (sbbox[2] - sbbox[0])/2, sbbox[2] - 1)
        self.position['offset'][1] = sbbox[1]
      else:
        self.position['offset'][0] = sbbox[2] - 1
        self.position['offset'][1] = \
          self.random.randint(sbbox[1], sbbox[3] - 1 - (sbbox[3] - sbbox[1])/2)
    elif self.direction in ('rightup', 'upright'):
      if self.random.randint(0,1):
        self.position['offset'][0] = \
          self.random.randint(sbbox[0], sbbox[2] - 1 - (sbbox[2] - sbbox[0])/2)
        self.position['offset'][1] = sbbox[3] - 1
      else:
        self.position['offset'][0] = sbbox[0]
        self.position['offset'][1] = \
          self.random.randint(sbbox[1] + (sbbox[3] - sbbox[1])/2, sbbox[3] - 1)
    elif self.direction in ('rightdown', 'downright'):
      if self.random.randint(0,1):
        self.position['offset'][0] = \
          self.random.randint(sbbox[0], sbbox[2] - 1 - (sbbox[2] - sbbox[0])/2)
        self.position['offset'][1] = sbbox[1]
      else:
        self.position['offset'][0] = sbbox[0]
        self.position['offset'][1] = \
          self.random.randint(sbbox[1], sbbox[3] - 1 - (sbbox[3] - sbbox[1])/2)

    # Increment the position by a random amount in the range
    # [0, shiftDuringSweep)
    if self.shiftDuringSweep > 1:
      prevShiftDuringSweep = self.shiftDuringSweep
      self.shiftDuringSweep = self.random.randint(0, self.shiftDuringSweep)
      self._nextSweepPosition()
      self.shiftDuringSweep = prevShiftDuringSweep
      if self.position['reset']:
        self.first()

    self.position['reset'] = True

# 需要导入模块: from nupic.vision.regions.ImageSensorExplorers.BaseExplorer import BaseExplorer [as 别名]
# 或者: from nupic.vision.regions.ImageSensorExplorers.BaseExplorer.BaseExplorer import first [as 别名]
  def first(self, seeking=False):
    """
    Set up the position.

    BaseExplorer picks image 0, offset (0,0), etc., but explorers that wish
    to set a different first position should extend this method. Such explorers
    may wish to call BaseExplorer.first(center=False), which initializes the
    position tuple but does not call centerImage() (which could cause
    unnecessary filtering to occur).

    seeking -- Passed from seek() through next() to avoid loading images
      unnecessarily when seeking.
    """

    BaseExplorer.first(self, center=False)

    if not self.numImages:
      return

    if not self.replacement \
        and len(self.history) == self.getNumIterations(None):
      # All images have been visited
      self.history = []

    if self.equalizeCategories:
      # Breakdown the images by category
      if self.imagesByCat is None:
        categoryIndex = []
        for k in range(self.numImages):
          categoryIndex += [self.getImageInfo(k)['categoryIndex']]
        categories = list(set(categoryIndex))
        numCats = len(categories)

        catPopulation = {}
        imagesByCat = {}
        for catIndex in categories:
          #catPopulation[catIndex] = len([c for c in categoryIndex if c == catIndex])
          imagesByCat[catIndex] = [k for k, c in enumerate(categoryIndex) if c == catIndex]
          catPopulation[catIndex] = len(imagesByCat[catIndex])
        minNumSamples = min([pop for (cat, pop) in catPopulation.items()])
        totalNumSamples = minNumSamples * numCats
        # Store
        self.imagesByCat = imagesByCat
        self.categories = categories
        self.numCategories = numCats
        self.nextCatIndex = 0

      # Pick random image from next category
      thisCat = self.imagesByCat[self.nextCatIndex]
      #randomImageIndex = random.randint(0, len(thisCat))
      self.position['image'] = self.random.choice(thisCat)
      self.position['filters'] = self.pickRandomFilters(self.random)
      self.nextCatIndex = (self.nextCatIndex + 1) % self.numCategories

    else:
      # Pick a random image and set of filters
      while self.start >= 0:

        finished = False
        while not finished:
          # Pick a position randomly
          self.position['image'] = self.pickRandomImage(self.random)
          self.position['filters'] = self.pickRandomFilters(self.random)
          # Pick again if not replacing and this position has been visited
          if self.replacement or (self.position['image'],
              self.position['filters']) not in self.history:
            finished = True

        if not self.replacement:
          # Remember this position
          self.history.append(
            (self.position['image'], self.position['filters'][:]))

        self.start -= 1

      self.start = 0

    if not seeking:
      self.centerImage()

# 需要导入模块: from nupic.vision.regions.ImageSensorExplorers.BaseExplorer import BaseExplorer [as 别名]
# 或者: from nupic.vision.regions.ImageSensorExplorers.BaseExplorer.BaseExplorer import first [as 别名]
  def next(self, seeking=False):
    """Move to the next saccade position if number of saccades on an image
    has not reached it's maximum. Otherwise, load the next random image.

    :param seeking: If True, don't do unnecessary computations
    """
    if not self.numImages:
      return

    if (not self.replacement
        and len(self.history) == self.getNumIterations(None)):
      # All images have been visited
      self.history = []
      self.imageHistory = []

    while True:
      if self.saccadeIndex is 0 or self.saccadeIndex > (self.numSaccades - 1):
        while self.position["image"] in self.imageHistory:
          BaseExplorer.first(self)
          self.position["image"] = self.pickRandomImage(self.random)
        self.imageHistory.append(self.position["image"])
        self.prevSaccade = {"prevOffset": deepcopy(self.position["offset"]),
                            "direction": None,
                            "length": None,
                            "newOffset": deepcopy(self.position["offset"])}
        historyItem = (self.position["image"],
                       self.saccadeIndex)
        if not self.replacement:
          # Add to the history
          self.history.append(historyItem)
        self.saccadeIndex = 1
        return

      if not seeking:
        saccadeDirection = self.random.choice(_DIRECTIONS)
        saccadeLength =  self.random.randint(self.saccadeMin, self.saccadeMax)

      historyItem = (self.position["image"],
                     self.saccadeIndex)
      if self.replacement or historyItem not in self.history:
        # Use this position
        if not seeking:
          imageSize = self.getFilteredImages()[0].size
          if not self._checkFoveaInImage(imageSize,
                                         saccadeLength,
                                         saccadeDirection):
            continue

          self.prevSaccade = {"prevOffset": deepcopy(self.position["offset"]),
                              "direction": saccadeDirection,
                              "length": saccadeLength}
          if saccadeDirection == "left":
            self.position["offset"][0] -= saccadeLength
          elif saccadeDirection == "right":
            self.position["offset"][0] += saccadeLength
          elif saccadeDirection == "up":
            self.position["offset"][1] -= saccadeLength
          elif saccadeDirection == "down":
            self.position["offset"][1] += saccadeLength
          self.prevSaccade["newOffset"] = deepcopy(self.position["offset"])


        if not self.replacement:
          # Add to the history
          self.history.append(historyItem)
        self.saccadeIndex += 1
        return