def __init__(self, grammar=None, value=None, f=None, maxnodes=25, args=['x'], **kwargs):
# Save all of our keywords
self.__dict__.update(locals())
if value is None and grammar is not None:
value = grammar.generate()
FunctionHypothesis.__init__(self, value=value, f=f, args=args, **kwargs)
self.likelihood = 0.0
self.rules_vector = None
def __init__(self, grammar=None, value=None, f=None, maxnodes=25, **kwargs):
if 'args' in kwargs:
assert False, "*** Use of 'args' is deprecated. Use display='...' instead."
# Save all of our keywords
self_update(self, locals())
if value is None and grammar is not None:
value = grammar.generate()
FunctionHypothesis.__init__(self, value=value, f=f, **kwargs)
self.likelihood = 0.0
self.rules_vector = None
def __call__(self, *args):
# NOTE: This no longer catches all exceptions.
try:
return FunctionHypothesis.__call__(self, *args)
except TypeError as e:
print "TypeError in function call: ", e, str(self), " ; ", type(self), args
raise TypeError
except NameError as e:
print "NameError in function call: ", e, " ; ", str(self), args
raise NameError
def force_function(self, w, f):
"""
Allow force_function
"""
# If this does not exist, make a function hypothesis from scratch with nothing in it.
if w not in self.value:
self.value[w] = FunctionHypothesis(value=None, args=None)
self.value[w].force_function(f)
def __init__(self,
grammar=None,
value=None,
f=None,
maxnodes=25,
**kwargs):
if 'args' in kwargs:
assert False, "*** Use of 'args' is deprecated. Use display='...' instead."
# Save all of our keywords
self_update(self, locals())
if value is None and grammar is not None:
value = grammar.generate()
FunctionHypothesis.__init__(self, value=value, f=f, **kwargs)
self.likelihood = 0.0
self.rules_vector = None
def __call__(self, *args):
# NOTE: This no longer catches all exceptions.
try:
return FunctionHypothesis.__call__(self, *args)
except TypeError as e:
print "TypeError in function call: ", e, str(self), " ; ", type(
self), args
raise TypeError
except NameError as e:
print "NameError in function call: ", e, " ; ", str(self), args
raise NameError
def recursive_call(self, *args):
"""
This gets called internally on recursive calls. It keeps track of the depth and throws an error if you go too deep
"""
self.recursive_call_depth += 1
if self.recursive_call_depth > self.recursive_depth_bound:
raise RecursionDepthException
# Call with sending myself as the recursive call
return FunctionHypothesis.__call__(self, self.recursive_call, *args)
def __init__(self,
grammar,
value=None,
f=None,
node_counts=None,
maxnodes=25,
recurse_bound=25,
display="lambda recurse_, x: %s",
**kwargs):
"""
Initializer. recurse gives the name for the recursion operation internally.
"""
assert "lambda recurse_" in display, "*** RecursiveLOTHypothesis must have 'recurse_' as first display element." # otherwise it can't eval
# save recurse symbol
self.recursive_depth_bound = recurse_bound # how deep can we recurse?
self.recursive_call_depth = 0 # how far down have we recursed?
if 'args' in kwargs:
assert False, "*** Use of 'args' is deprecated. Use display='...' instead."
# Save all of our keywords
self_update(self, locals())
grammar.update_alphas() # make sure alpha/sigma arrays are initialized
if value is None:
value, self.node_counts = grammar.generate_with_counts()
else:
self.node_counts = node_counts
self.tree_size = np.sum(self.node_counts)
FunctionHypothesis.__init__(self,
value=value,
f=f,
display=display,
**kwargs)
self.likelihood = 0.0
self.compute_prior()
self.rules_vector = None
def __init__(self,
grammar=None,
value=None,
f=None,
maxnodes=25,
args=['x'],
**kwargs):
# Save all of our keywords
self.__dict__.update(locals())
if value is None and grammar is not None:
value = grammar.generate()
FunctionHypothesis.__init__(self,
value=value,
f=f,
args=args,
**kwargs)
self.likelihood = 0.0
self.rules_vector = None
def __init__(self, grammar, value=None, f=None, start=None, ALPHA=0.9, maxnodes=25, args=['x'],
proposal_function=None, **kwargs):
self.grammar = grammar
self.f = f
self.ALPHA = ALPHA
self.maxnodes = maxnodes
# Save all of our keywords (though we don't need v)
self.__dict__.update(locals())
# If this is not specified, defaultly use grammar
if start is None:
self.start = grammar.start
if value is None:
value = grammar.generate(self.start)
FunctionHypothesis.__init__(self, value=value, f=f, args=args, **kwargs)
# Save a proposal function
# TODO: How to handle this in copying?
if proposal_function is None:
self.proposal_function = RegenerationProposal(self.grammar)
self.likelihood = 0.0
self.rules_vector = None
def __call__(self, *args):
"""
The main calling function. Resets recursive_call_depth and then calls
"""
self.recursive_call_depth = 0
try:
# call with passing self.recursive_Call as the recursive call
return FunctionHypothesis.__call__(self, self.recursive_call,
*args)
except TypeError as e:
print "TypeError in function call: ", e, str(self), " ; ", type(
self), args
raise TypeError
except NameError as e:
print "NameError in function call: ", e, " ; ", str(self), args
raise NameError