def asVentureValue(self, thing):
thing = np.asarray(thing)
if len(thing.shape) == 0:
return vv.VentureNumber(float(thing))
elif len(thing.shape) == 1:
subtype = NumberType(thing.dtype.name)
else:
subtype = self
return vv.VentureArrayUnboxed(thing, subtype)
def testGradientOfSimulateOfLookup2():
from venture.lite.sp_registry import builtInSPs
sp = builtInSPs()["lookup"]
args = [vv.VentureArrayUnboxed([0, 0], t.Number), vv.VentureNumber(1)]
grad = sp.outputPSP.gradientOfSimulate(MockArgs(args, sp.constructSPAux()),
vv.VentureNumber(0),
vv.VentureNumber(1))
assert grad[0].lookup(vv.VentureNumber(0)) == vv.VentureNumber(0)
assert grad[0].lookup(vv.VentureNumber(1)) == vv.VentureNumber(1)
assert grad[1] == 0
def asPython(self, thing):
if isinstance(thing, vv.VentureBool):
return thing.getBool()
if isinstance(thing, vv.VentureInteger):
return thing.getInteger()
if isinstance(thing, vv.VentureNumber):
return thing.getNumber()
if isinstance(thing, vv.VentureAtom):
return thing # Atoms are valid elements of expressions
if isinstance(thing, vv.VentureSymbol):
return thing.getSymbol()
if thing.isValidCompoundForm():
# Leave quoted data as they are, on the grounds that (quote
# <thing>) should evaluate to exactly that <thing>, even if
# constructed programmatically from a <thing> that does not
# normally appear in expressions.
if thing.size() == 2 \
and thing.lookup(vv.VentureNumber(0)) == vv.VentureSymbol("quote"):
return ["quote", thing.lookup(vv.VentureNumber(1))]
else:
return thing.asPythonList(self)
# Most other things are represented as themselves.
return thing
def asVentureValue(self, thing):
if isinstance(thing, bool) or isinstance(thing, np.bool_):
return vv.VentureBool(thing)
if isinstance(thing, int):
return vv.VentureInteger(thing)
if isinstance(thing, numbers.Number):
return vv.VentureNumber(thing)
if isinstance(thing, vv.VentureAtom):
return thing
if isinstance(thing, str):
return vv.VentureSymbol(thing)
if hasattr(thing, "__getitem__"): # Already not a string
return vv.VentureArray([self.asVentureValue(val) for val in thing])
if isinstance(thing, vv.VentureValue):
return thing
else:
raise Exception("Cannot convert Python object %r to a Venture " \
"Expression" % thing)
def asVentureValue(self, thing):
if isinstance(thing, bool) or isinstance(thing, np.bool_):
return vv.VentureBool(thing)
if isinstance(thing, int):
return vv.VentureInteger(thing)
if isinstance(thing, numbers.Number):
return vv.VentureNumber(thing)
if isinstance(thing, str):
return vv.VentureString(thing)
if isinstance(thing, dict):
return vv.VentureDict(
OrderedDict([(self.asVentureValue(key),
self.asVentureValue(val))
for (key, val) in thing.iteritems()]))
if hasattr(thing, "__getitem__"): # Already not a string
return vv.VentureArray([self.asVentureValue(val) for val in thing])
if isinstance(thing, vv.VentureValue):
return thing
else:
raise Exception("Cannot convert Python object %r to a Venture " \
"Expression" % thing)
def __venture_start__(r):
r.bind_callback("foo", lambda _inferrer: None)
return v.VentureNumber(
7) # To test that load_plugin will forward the return value
def number(self, **_kwargs):
return v.VentureNumber(npr.uniform(-10, 10))
def asVentureValue(self, thing):
assert isinstance(thing, numbers.Number)
assert 0 <= thing and thing <= 1
return vv.VentureNumber(thing)
def asVentureValue(self, thing):
assert thing <= 0
return vv.VentureNumber(thing)
def probability(self, **_kwargs):
return v.VentureNumber(npr.uniform(0, 1))
def asVentureValue(self, thing):
return vv.VentureNumber(thing)
def primitive_infer(trace, exp):
operator = exp[0]
if operator == "resimulation_mh":
(scaffolders, transitions, _) = dispatch_arguments(trace, exp)
def doit(scaffolder):
return mixMH(trace, scaffolder, MHOperator())
return transloop(trace, transitions,
scaffolder_loop(scaffolders, doit))
elif operator == "func_mh":
(scaffolders, transitions, _) = dispatch_arguments(trace, exp)
def doit(scaffolder):
return mixMH(trace, scaffolder, FuncMHOperator())
return transloop(trace, transitions,
scaffolder_loop(scaffolders, doit))
elif operator == "draw_scaffold":
(scaffolders, _transitions, _) = dispatch_arguments(trace, exp)
drawScaffold(trace, scaffolders[0])
elif operator == "mh_kernel_update":
(scope, block, transitions, extra) = parse_arguments(trace, exp)
return transloop(trace, transitions, lambda : \
do_mh_kernel_update(trace, scope, block, extra))
elif operator == "subsampled_mh":
(scope, block, transitions, extra) = parse_arguments(trace, exp)
return transloop(trace, transitions, lambda : \
do_subsampled_mh(trace, scope, block, extra))
elif operator == "subsampled_mh_check_applicability":
(scope, block, _transitions, _) = parse_arguments(trace, exp)
SubsampledBlockScaffoldIndexer(scope, block).checkApplicability(trace)
# Does not affect nodes
return 0.0
elif operator == "subsampled_mh_make_consistent":
(scope, block, transitions, _) = parse_arguments(trace, exp)
return transloop(trace, transitions, lambda : \
do_subsampled_mh_make_consistent(trace, scope, block, extra))
elif operator == "meanfield":
(scaffolders, transitions, extra) = dispatch_arguments(trace, exp)
steps = int(extra[0])
def doit(scaffolder):
return mixMH(trace, scaffolder, MeanfieldOperator(steps, 0.0001))
return transloop(trace, transitions,
scaffolder_loop(scaffolders, doit))
elif operator == "hmc":
(scaffolders, transitions, (epsilon,
L)) = dispatch_arguments(trace, exp)
assert isinstance(L, numbers.Number)
assert isinstance(epsilon, numbers.Number)
def doit(scaffolder):
return mixMH(trace, scaffolder,
HamiltonianMonteCarloOperator(epsilon, int(L)))
return transloop(trace, transitions,
scaffolder_loop(scaffolders, doit))
elif operator == "gibbs":
(scaffolders, transitions, _) = dispatch_arguments(trace, exp)
def doit(scaffolder):
return mixMH(trace, scaffolder, EnumerativeGibbsOperator())
return transloop(trace, transitions,
scaffolder_loop(scaffolders, doit))
elif operator == "emap":
(scaffolders, transitions, _) = dispatch_arguments(trace, exp)
def doit(scaffolder):
return mixMH(trace, scaffolder, EnumerativeMAPOperator())
return transloop(trace, transitions,
scaffolder_loop(scaffolders, doit))
elif operator == "gibbs_update":
(scope, block, transitions, _) = parse_arguments(trace, exp)
return transloop(trace, transitions, lambda : \
mixMH(trace, BlockScaffoldIndexer(scope, block, updateValues=True),
EnumerativeGibbsOperator()))
elif operator == "slice":
(scaffolders, transitions, (w, m)) = dispatch_arguments(trace, exp)
def doit(scaffolder):
return mixMH(trace, scaffolder, StepOutSliceOperator(w, m))
return transloop(trace, transitions,
scaffolder_loop(scaffolders, doit))
elif operator == "slice_doubling":
(scaffolders, transitions, (w, p)) = dispatch_arguments(trace, exp)
def doit(scaffolder):
return mixMH(trace, scaffolder, DoublingSliceOperator(w, p))
return transloop(trace, transitions,
scaffolder_loop(scaffolders, doit))
elif operator == "pgibbs":
(scope, block, transitions, extra) = parse_arguments(trace, exp)
particles = int(extra[0])
if isinstance(block, list): # Ordered range
(_, min_block, max_block) = block
scaffolder = BlockScaffoldIndexer(scope, "ordered_range",
(min_block, max_block))
return transloop(trace, transitions, lambda : \
mixMH(trace, scaffolder, PGibbsOperator(particles)))
else:
return transloop(trace, transitions, lambda : \
mixMH(trace, BlockScaffoldIndexer(scope, block),
PGibbsOperator(particles)))
elif operator == "pgibbs_update":
(scope, block, transitions, extra) = parse_arguments(trace, exp)
particles = int(extra[0])
if isinstance(block, list): # Ordered range
(_, min_block, max_block) = block
scaffolder = BlockScaffoldIndexer(scope,
"ordered_range",
(min_block, max_block),
updateValues=True)
return transloop(trace, transitions, lambda : \
mixMH(trace, scaffolder, PGibbsOperator(particles)))
else:
return transloop(trace, transitions, lambda : \
mixMH(trace, BlockScaffoldIndexer(scope, block, updateValues=True),
PGibbsOperator(particles)))
elif operator == "func_pgibbs":
(scope, block, transitions, extra) = parse_arguments(trace, exp)
particles = int(extra[0])
if isinstance(block, list): # Ordered range
(_, min_block, max_block) = block
scaffolder = BlockScaffoldIndexer(scope, "ordered_range",
(min_block, max_block))
return transloop(trace, transitions, lambda : \
mixMH(trace, scaffolder, ParticlePGibbsOperator(particles)))
else:
return transloop(trace, transitions, lambda : \
mixMH(trace, BlockScaffoldIndexer(scope, block),
ParticlePGibbsOperator(particles)))
elif operator == "func_pmap":
(scope, block, transitions, extra) = parse_arguments(trace, exp)
particles = int(extra[0])
if isinstance(block, list): # Ordered range
(_, min_block, max_block) = block
scaffolder = BlockScaffoldIndexer(scope, "ordered_range",
(min_block, max_block))
return transloop(trace, transitions, lambda : \
mixMH(trace, scaffolder, ParticlePMAPOperator(particles)))
else:
return transloop(trace, transitions, lambda : \
mixMH(trace, BlockScaffoldIndexer(scope, block),
ParticlePMAPOperator(particles)))
elif operator == "gradient_ascent":
# XXX, in order to mak default args work here, I need to check the lenght of
# the args to `gradient_ascent` conditioned on whether the second arg is a
# VentureSymbol.
if isinstance(exp[1], v.VentureSymbol):
expected_arg_length = 6
else:
expected_arg_length = 5
if len(exp) == expected_arg_length - 2:
exp += [v.VentureNumber(1.0), v.VentureNumber(1.0)]
elif len(exp) == expected_arg_length - 1:
exp += [v.VentureNumber(1.0)]
elif len(exp) < expected_arg_length - 2:
raise ValueError('Not enough args for gradient_ascent')
(scaffolders, transitions, extra) = dispatch_arguments(trace, exp)
(rate, steps) = extra
def doit(scaffolder):
return mixMH(trace, scaffolder,
GradientAscentOperator(rate, int(steps)))
return transloop(trace, transitions,
scaffolder_loop(scaffolders, doit))
elif operator == "nesterov":
(scaffolders, transitions, (rate,
steps)) = dispatch_arguments(trace, exp)
def doit(scaffolder):
return mixMH(
trace, scaffolder,
NesterovAcceleratedGradientAscentOperator(rate, int(steps)))
return transloop(trace, transitions,
scaffolder_loop(scaffolders, doit))
elif operator == "rejection":
(scaffolders, transitions, extra) = dispatch_arguments(trace, exp)
if len(extra) >= 1:
logBound = float(extra[0])
else:
logBound = None
if len(extra) == 2:
trials = int(extra[1])
else:
trials = None
def doit(scaffolder):
return mixMH(trace, scaffolder,
RejectionOperator(logBound, trials))
return transloop(trace, transitions,
scaffolder_loop(scaffolders, doit))
elif operator == "bogo_possibilize":
(scaffolders, transitions, _) = dispatch_arguments(trace, exp)
def doit(scaffolder):
return mixMH(trace, scaffolder, BogoPossibilizeOperator())
return transloop(trace, transitions,
scaffolder_loop(scaffolders, doit))
elif operator == "log_rejection_bound_at":
(scaffolders, _transitions, _) = dispatch_arguments(trace, exp)
assert len(
scaffolders) == 1, "log_rejection_bound_at doesn't support 'each'"
scaffold = scaffolders[0].sampleIndex(trace)
return computeRejectionBound(trace, scaffold, scaffold.border[0])
elif operator == "print_scaffold_stats":
(scaffolders, _transitions, _) = dispatch_arguments(trace, exp)
scaffold = scaffolders[0].sampleIndex(trace)
scaffold.show()
return scaffold.numAffectedNodes()
else:
raise Exception("INFER %s is not implemented" % operator)
def nonpositive(self, **_kwargs):
return v.VentureNumber(log(npr.uniform(0, 1)))
def grad_vector_times_scalar(args, direction):
dot_prod = v.vv_dot_product(v.VentureArrayUnboxed(args[0], t.NumberType()),
direction)
return [direction * args[1], v.VentureNumber(dot_prod)]
def mk_dict(*entries):
return dict([(e.lookup(v.VentureNumber(0)), e.lookup(v.VentureNumber(1)))
for e in entries])
def testCallbackReturns():
ripl = get_ripl()
ripl.bind_callback("three", lambda _inferrer: v.VentureNumber(3))
ripl.infer("(do (x <- (call_back three)) (assert (eq 3 x)))")
def count_nodes(ripl):
scope = vv.VentureNumber(0)
block = vv.VentureNumber(0)
return ripl.sivm.core_sivm.engine.getDistinguishedTrace().numNodesInBlock(
scope, block)
def vvsum(venture_array):
# TODO Why do the directions come in and out as Venture Values
# instead of being unpacked by f_type.gradient_type()?
return v.VentureNumber(sum(venture_array.getArray(t.NumberType())))
def positive(self, **_kwargs):
return v.VentureNumber(npr.uniform(0, 10)) # TODO Prevent zero
def count_nodes(engine):
scope = vv.VentureNumber(0)
block = vv.VentureNumber(0)
return engine.getDistinguishedTrace().numNodesInBlock(scope, block)
