Python LOTHypothesis.LOTHypothesis類代碼示例

    def __init__(self, constant_sd=1.0, fit_only_once=True, **kwargs):
        """
        :param constant_sd: The SD of our constants in the prior
        :param fit_only_once: Do we fit multiple times or just take the first?
        """
        LOTHypothesis.__init__(self, grammar, display='lambda x,'+','.join(CONSTANT_NAMES)+": %s", **kwargs)

        self.constant_sd=constant_sd # also the prior SD
        self.parameters = self.sample_constants()
        self.fit_only_once = fit_only_once

 def __call__(self, *vals):
     """
         Must overwrite call in order to include the constants
     """
     vals = list(vals)
     vals.extend(self.CONSTANT_VALUES)
     return LOTHypothesis.__call__(self, *vals)

 def __call__(self, *vals):
     """
         Must overwrite call in order to include the constants
     """
     vals = list(vals)
     vals.extend(self.parameters)
     return LOTHypothesis.__call__(self, *vals)

    def __call__(self, *args, **kwargs):
        # we have to mod this to insert the spaces since they aren't part of cons above
        ret = LOTHypothesis.__call__(self, *args, **kwargs)

        out = dict()
        for k, v in ret.items():
            out[" ".join(k)] = v
        return out

def prior_sample(h0, data, N):
	"""
		Just use the grammar and returntype of h0 to sample from the prior
		NOTE: Only implemented for LOTHypothesis
	"""
	assert isinstance(h0, LOTHypothesis)
	
	# extract from the grammar
	G = h0.grammar 
	rt = h0.value.returntype
	
	for i in xrange(N):
		if LOTlib.SIG_INTERRUPTED: break
	
		h = LOTHypothesis(G, start=rt)
		h.compute_posterior(data)
		
		yield h

    def __call__(self, *args, **kwargs):
        if self.value_set is None:
            value_set = LOTHypothesis.__call__(self)
            # Restrict our concept to being within our domain; also handle 'None' call values
            if isinstance(value_set, set):
                value_set = [x for x in value_set if x <= self.domain]
            else:
                value_set = []
            self.value_set = value_set

        return self.value_set

    def __call__(self, *args, **kwargs):
        # Sometimes self.value has too many nodes
        try:
            value_set = LOTHypothesis.__call__(self)
        except TooBigException:
            value_set = set()

        if isinstance(value_set, set):
            # Restrict our concept to being within our domain
            value_set = [x for x in value_set if (1 <= x <= self.domain)]
        else:
            # Sometimes self() returns None
            value_set = set()

        return value_set

 def __init__(self, grammar, alpha=0.9, domain=100, **kwargs):
     LOTHypothesis.__init__(self, grammar, args=[], **kwargs)
     self.alpha = alpha
     self.domain = domain

 def __init__(self, *args, **kwargs ):
     LOTHypothesis.__init__(self, grammar, display='lambda x,y: %s', **kwargs)
     super(CRHypothesis, self).__init__(*args, **kwargs)

 def __init__(self, ALPHA=0.9, **kwargs):
     LOTHypothesis.__init__(self, grammar, **kwargs)
     self.ALPHA = ALPHA

 def __init__(self, grammar=grammar, **kwargs):
     LOTHypothesis.__init__(self, grammar, display='lambda C : %s', maxnodes=200, **kwargs)
     # self.outlier = -100 # for MultinomialLikelihoodLog
     self.alphabet_size = len(TERMINALS)

 def __init__(self, value=None, alpha=0.99, baserate=0.5):
     LOTHypothesis.__init__(self, grammar, value=value, display='lambda S, x: %s', alpha=alpha, baserate=baserate)

 def __init__(self, **kwargs):
     LOTHypothesis.__init__(self, grammar, **kwargs)

 def __init__(self, **kwargs ):
     LOTHypothesis.__init__(self, grammar, args=['x', 'y'], **kwargs)

 def compute_prior(self):
     # Add together the LOT prior and the constant prior, here just a gaussian
     return LOTHypothesis.compute_prior(self) +\
            sum(map(lambda x: normlogpdf(x,0.0,self.constant_sd), self.parameters))