Example #1
0
	def cluster(self, u, ndim, keepRadius=False):
		"""
		
		"""
		if self.verbose: print 'building region ...'
		if len(u) > 10:
			if keepRadius and self.region is not None and 'maxdistance' in self.region:
				maxdistance = self.region['maxdistance']
			else:
				if self.radial:
					if self.jackknife:
						#maxdistance = initial_rdistance_guess(u, k=1, metric=self.metric)
						maxdistance = nearest_rdistance_guess(u, metric=self.metric)
					else:
						maxdistance = find_rdistance(u, nbootstraps=50, metric=self.metric, verbose=self.verbose)
				else:
					maxdistance = find_maxdistance(u)
			if self.force_shrink and self.region is not None and 'maxdistance' in self.region:
				maxdistance = min(maxdistance, self.region['maxdistance'])
			ulow  = numpy.max([u.min(axis=0) - maxdistance, numpy.zeros(ndim)], axis=0)
			uhigh = numpy.min([u.max(axis=0) + maxdistance, numpy.ones(ndim)], axis=0)
		else:
			maxdistance = None
			ulow = numpy.zeros(ndim)
			uhigh = numpy.ones(ndim)
		if self.verbose: print 'setting sampling region:', (ulow, uhigh), maxdistance
		self.region = dict(members=u, maxdistance=maxdistance, ulow=ulow, uhigh=uhigh)
		self.generator = None
Example #2
0
    def cluster(self, u, ndim, keepRadius=False):
        """
		
		"""
        if self.verbose: print('building region ...')
        if len(u) > 10:
            if keepRadius and self.region is not None and 'maxdistance' in self.region:
                maxdistance = self.region['maxdistance']
            else:
                if self.radial:
                    if self.jackknife:
                        #maxdistance = initial_rdistance_guess(u, k=1, metric=self.metric)
                        maxdistance = nearest_rdistance_guess(
                            u, metric=self.metric)
                    else:
                        maxdistance = find_rdistance(u,
                                                     nbootstraps=20,
                                                     metric=self.metric,
                                                     verbose=self.verbose)
                else:
                    maxdistance = find_maxdistance(u)
            if self.force_shrink and self.region is not None and 'maxdistance' in self.region:
                maxdistance = min(maxdistance, self.region['maxdistance'])
            if self.keep_phantom_points and len(self.phantom_points) > 0:
                # add phantoms to u now
                print('including phantom points in cluster members',
                      self.phantom_points)
                u = numpy.vstack((u, self.phantom_points))
            ulow = numpy.max([u.min(axis=0) - maxdistance,
                              numpy.zeros(ndim)],
                             axis=0)
            uhigh = numpy.min([u.max(axis=0) + maxdistance,
                               numpy.ones(ndim)],
                              axis=0)
        else:
            maxdistance = None
            ulow = numpy.zeros(ndim)
            uhigh = numpy.ones(ndim)
        if self.verbose:
            print('setting sampling region:', (ulow, uhigh), maxdistance)
        self.region = dict(members=u,
                           maxdistance=maxdistance,
                           ulow=ulow,
                           uhigh=uhigh)
        self.generator = None
	def draw_constrained(self, Lmin, priortransform, loglikelihood, ndim, 
			previous, startu, startx, startL, starti, **kwargs):
		# compute RadFriends spheres
		u = numpy.array([u for u, _, L in previous if L >= Lmin])
		rebuilt = False
		if self.region is None or len(previous) % 50 == 0:
			# jackknife, is fast
			maxdistance = nearest_rdistance_guess(u, metric='euclidean')
			#maxdistance = find_rdistance(u, nbootstraps=50, metric='euclidean', verbose=False)
			# make sure we only shrink
			if self.region is not None and 'maxdistance' in self.region:
				maxdistance = min(maxdistance, self.region['maxdistance'])
			#print 'new distance:', maxdistance
			# compute enclosing rectangle for quick checks
			ulow  = numpy.max([u.min(axis=0) - maxdistance, numpy.zeros(ndim)], axis=0)
			uhigh = numpy.min([u.max(axis=0) + maxdistance, numpy.ones(ndim)], axis=0)
			self.region = dict(members=u, maxdistance=maxdistance, ulow=ulow, uhigh=uhigh)
			
			self.direct_generator = self.generate_direct(ndim=ndim)
			self.friends_generator = self.generate_from_friends(ndim=ndim)
			rebuilt = True
		
		ntoaccept = 0
		if self.phase == 0:
			# draw from rectangle until sphere rejection drops below 1%
			for u, ntotal in self.direct_generator:
				x = priortransform(u)
				L = loglikelihood(x)
				self.nfriends += 1
				ntoaccept += 1
				if L >= Lmin:
					if ntotal >= 200:
						print('Drawing from prior is becoming inefficient: %d draws before accept' % ntotal)
						print()
					if ntoaccept >= 200:
						print('RadFriends is becoming inefficient: %d draws until accept' % ntoaccept)
						print()
					self.nfriends_accepts += 1
					return u, x, L, ntoaccept
				if ntotal >= 1000:
					# drawing directly from prior 
					# becomes inefficient as we go to
					# small region
					# switch to drawing from Friends
					print('switching to Friends sampling phase')
					print()
					self.phase = 1
					break
				if ntoaccept >= 2000:
					print('switching to local steps sampling phase')
					print()
					self.phase = 2
					# drawing using RadFriends can become
					# inefficient in high dimensionality
					# switch to local step sampling
					break
		if self.phase == 1:
			# draw from spheres until acceptance rate drops below 0.05%
			for u, ntotal in self.friends_generator:
				x = priortransform(u)
				L = loglikelihood(x)
				self.nfriends += 1
				ntoaccept += 1
				if L >= Lmin:
					if ntoaccept >= 200:
						print('RadFriends is becoming inefficient: %d draws until accept' % ntoaccept)
						print()
					self.nfriends_accepts += 1
					return u, x, L, ntoaccept
				if ntoaccept >= 2000:
					print( 'switching to local steps sampling phase')
					print()
					self.phase = 2
					# drawing using RadFriends can become
					# inefficient in high dimensionality
					# switch to local step sampling
					break
		#print 'falling through...'
		# then do local step sampling
		i = starti # particle ID
		u1, x1, L1, k = self.local_step_sample(i, startu, startx, startL, 
			Lmin, priortransform, loglikelihood, u)
		#self.stats()
		self.adapt()
		return u1, x1, L1, k + ntoaccept