def test_you_can_throw_a_java_exception() -> None:
with pytest.raises(JavaException, match="Illegal initial capacity: -1"):
context = KeanuContext()
try:
context.jvm_view().java.util.HashMap(-1)
except Py4JJavaError as e:
raise JavaException(e)
def test_you_can_get_info_from_a_java_exception() -> None:
context = KeanuContext()
with pytest.raises(Py4JJavaError) as excinfo:
context.jvm_view().java.util.HashMap(-1)
java_exception = JavaException(excinfo.value)
assert java_exception.get_class() == "java.lang.IllegalArgumentException"
assert java_exception.get_message() == "Illegal initial capacity: -1"
assert java_exception.unwrap().getCause() == None
def test_its_repr_method_gives_you_the_stack_trace() -> None:
context = KeanuContext()
with pytest.raises(Py4JJavaError) as excinfo:
context.jvm_view().java.util.HashMap(-1)
java_exception = JavaException(excinfo.value)
assert str(java_exception).replace(
"\r", "") == """An error occurred while calling None.java.util.HashMap.
from typing import List, Any, Callable, Dict
from py4j.java_gateway import java_import
from keanu.base import JavaObjectWrapper
from keanu.context import KeanuContext
from keanu.tensor import Tensor
from keanu.vartypes import numpy_types
k = KeanuContext()
java_import(
k.jvm_view(),
"io.improbable.keanu.algorithms.mcmc.proposal.GaussianProposalDistribution"
)
java_import(
k.jvm_view(),
"io.improbable.keanu.algorithms.mcmc.proposal.PriorProposalDistribution")
proposal_distribution_types: Dict[str, Callable] = {
"gaussian": k.jvm_view().GaussianProposalDistribution,
"prior": k.jvm_view().PriorProposalDistribution,
}
class ProposalDistribution(JavaObjectWrapper):
def __init__(self,
type_: str,
sigma: numpy_types = None,
listeners: List[Any] = []) -> None:
ctor = proposal_distribution_types[type_]
from typing import Dict, Callable, Optional
from py4j.java_collections import JavaMap
from py4j.java_gateway import java_import
from keanu.context import KeanuContext
from keanu.functional import Consumer, Supplier
from keanu.vertex.base import Vertex
from keanu.vertex.label import _VertexLabel
context = KeanuContext()
java_import(context.jvm_view(),
"io.improbable.keanu.vertices.model.LambdaModelVertex")
class LambdaModel(Vertex):
def __init__(self,
inputs: Dict[str, Vertex],
executor: Callable,
update_values: Callable = None,
label: Optional[str] = None) -> None:
self.vertices_wrapped = inputs
vertex_map = LambdaModel.__to_java_map(inputs)
self.executor = executor
self.update_values = update_values or (lambda: self.vertices_wrapped)
vertex = context.jvm_view().LambdaModelVertex(
vertex_map, Consumer(self.__execute),
Supplier(lambda: self.__update_value()))
super(LambdaModel, self).__init__(vertex, label)
from py4j.java_gateway import java_import, JavaObject
from py4j.java_collections import JavaList
from keanu.context import KeanuContext
from keanu.tensor import Tensor
from keanu.vertex.base import Vertex
from keanu.net import BayesNet
from typing import Any, Iterable, Dict, List, Tuple, Generator
from keanu.vartypes import sample_types, sample_generator_types
k = KeanuContext()
java_import(k.jvm_view(),
"io.improbable.keanu.algorithms.mcmc.MetropolisHastings")
java_import(k.jvm_view(), "io.improbable.keanu.algorithms.mcmc.NUTS")
java_import(k.jvm_view(), "io.improbable.keanu.algorithms.mcmc.Hamiltonian")
algorithms = {
'metropolis': k.jvm_view().MetropolisHastings,
'NUTS': k.jvm_view().NUTS,
'hamiltonian': k.jvm_view().Hamiltonian
}
def sample(net: BayesNet,
sample_from: Iterable[Vertex],
algo: str = 'metropolis',
draws: int = 500,
drop: int = 0,
down_sample_interval: int = 1) -> sample_types:
vertices_unwrapped = k.to_java_object_list(sample_from)
from py4j.java_gateway import java_import
from keanu.base import JavaObjectWrapper
from keanu.context import KeanuContext
k = KeanuContext()
java_import(k.jvm_view(), "io.improbable.keanu.vertices.VertexLabel")
class _VertexLabel(JavaObjectWrapper):
"""
This class is intended for private use - as a user you should only need to specify string values.
It's used behind the scenes e.g. in :class:`keanu.vertex.lambda_model.LambdaModel`
"""
__separator = "."
def __init__(self, name: str):
parts = name.split(_VertexLabel.__separator)
if len(parts) == 1:
java_object = k.jvm_view().VertexLabel(name)
else:
java_object = k.jvm_view().VertexLabel(
parts[0], k.to_java_string_array(parts[1:]))
super(_VertexLabel, self).__init__(java_object)
def get_name(self) -> str:
return self.unwrap().getQualifiedName()
from py4j.java_collections import JavaList
from py4j.java_gateway import java_import, JavaObject
from keanu.algorithm._proposal_distribution import ProposalDistribution
from keanu.context import KeanuContext
from keanu.net import BayesNet, ProbabilisticModel, ProbabilisticModelWithGradient
from keanu.plots import traceplot
from keanu.tensor import Tensor
from keanu.vartypes import sample_types, sample_generator_types, numpy_types, sample_generator_dict_type, tensor_arg_types
from keanu.vertex.base import Vertex
COLUMN_HEADER_FOR_SCALAR = (0, )
k = KeanuContext()
java_import(k.jvm_view(),
"io.improbable.keanu.algorithms.mcmc.MetropolisHastings")
java_import(k.jvm_view(), "io.improbable.keanu.algorithms.mcmc.nuts.NUTS")
java_import(
k.jvm_view(),
"io.improbable.keanu.algorithms.mcmc.RollBackToCachedValuesOnRejection")
java_import(k.jvm_view(), "io.improbable.keanu.algorithms.sampling.Forward")
class PosteriorSamplingAlgorithm:
def __init__(self, sampler: JavaObject):
self._sampler = sampler
def get_sampler(self) -> JavaObject:
return self._sampler
import numpy as np
from numpy import ndarray
from py4j.java_gateway import java_import, JavaObject, JavaMember, is_instance_of
from typing import Any
from keanu.base import JavaObjectWrapper
from keanu.context import KeanuContext
from keanu.functional import Function
from .vartypes import (numpy_types, tensor_arg_types, primitive_types, runtime_int_types, runtime_float_types,
runtime_bool_types, runtime_numpy_types, runtime_pandas_types, runtime_primitive_types,
primitive_types)
k = KeanuContext()
java_import(k.jvm_view(), "io.improbable.keanu.tensor.dbl.DoubleTensor")
java_import(k.jvm_view(), "io.improbable.keanu.tensor.bool.BooleanTensor")
java_import(k.jvm_view(), "io.improbable.keanu.tensor.intgr.IntegerTensor")
java_import(k.jvm_view(), "io.improbable.keanu.util.Py4jByteArrayConverter")
class Tensor(JavaObjectWrapper):
def __init__(self, t: tensor_arg_types) -> None:
if isinstance(t, runtime_numpy_types):
super(Tensor, self).__init__(Tensor.__get_tensor_from_ndarray(t))
elif isinstance(t, runtime_pandas_types):
super(Tensor, self).__init__(Tensor.__get_tensor_from_ndarray(t.values))
elif isinstance(t, runtime_primitive_types):
super(Tensor, self).__init__(Tensor.__get_tensor_from_scalar(t))
else:
raise NotImplementedError("Generic types in an ndarray are not supported. Was given {}".format(type(t)))
return do_vertex_cast(ConstantDouble, input)
def cast_to_integer_vertex(input: vertex_constructor_param_types) -> Vertex:
return do_vertex_cast(ConstantInteger, input)
def cast_to_boolean_vertex(input: vertex_constructor_param_types) -> Vertex:
return do_vertex_cast(ConstantBoolean, input)
def cast_to_vertex(input: vertex_constructor_param_types) -> Vertex:
return do_inferred_vertex_cast({bool: ConstantBoolean, int: ConstantInteger, float: ConstantDouble}, input)
java_import(context.jvm_view(), "io.improbable.keanu.vertices.bool.nonprobabilistic.BooleanIfVertex")
java_import(context.jvm_view(), "io.improbable.keanu.vertices.bool.nonprobabilistic.BooleanProxyVertex")
java_import(context.jvm_view(), "io.improbable.keanu.vertices.bool.nonprobabilistic.CastToBooleanVertex")
java_import(context.jvm_view(), "io.improbable.keanu.vertices.bool.nonprobabilistic.ConstantBooleanVertex")
java_import(context.jvm_view(), "io.improbable.keanu.vertices.bool.nonprobabilistic.operators.NumericalEqualsVertex")
java_import(context.jvm_view(), "io.improbable.keanu.vertices.bool.nonprobabilistic.operators.binary.AndBinaryVertex")
java_import(context.jvm_view(), "io.improbable.keanu.vertices.bool.nonprobabilistic.operators.binary.OrBinaryVertex")
java_import(context.jvm_view(), "io.improbable.keanu.vertices.bool.nonprobabilistic.operators.binary.compare.EqualsVertex")
java_import(context.jvm_view(), "io.improbable.keanu.vertices.bool.nonprobabilistic.operators.binary.compare.GreaterThanOrEqualVertex")
java_import(context.jvm_view(), "io.improbable.keanu.vertices.bool.nonprobabilistic.operators.binary.compare.GreaterThanVertex")
java_import(context.jvm_view(), "io.improbable.keanu.vertices.bool.nonprobabilistic.operators.binary.compare.LessThanOrEqualVertex")
java_import(context.jvm_view(), "io.improbable.keanu.vertices.bool.nonprobabilistic.operators.binary.compare.LessThanVertex")
java_import(context.jvm_view(), "io.improbable.keanu.vertices.bool.nonprobabilistic.operators.binary.compare.NotEqualsVertex")
java_import(context.jvm_view(), "io.improbable.keanu.vertices.bool.nonprobabilistic.operators.multiple.BooleanConcatenationVertex")
java_import(context.jvm_view(), "io.improbable.keanu.vertices.bool.nonprobabilistic.operators.unary.BooleanReshapeVertex")
java_import(context.jvm_view(), "io.improbable.keanu.vertices.bool.nonprobabilistic.operators.unary.BooleanSliceVertex")
from keanu.base import JavaObjectWrapper
from keanu.context import KeanuContext
from py4j.java_gateway import java_import
from keanu.vertex import Vertex
k = KeanuContext()
java_import(k.jvm_view(), "io.improbable.keanu.util.*")
java_import(k.jvm_view(), "io.improbable.keanu.util.DescriptionCreator")
description_creator = k.jvm_view().io.improbable.keanu.util.DescriptionCreator(
)
def create_description(vertex: Vertex) -> str:
return description_creator.createDescription(vertex.unwrap())
from py4j.java_gateway import java_import, JavaObject, JavaClass
from keanu.context import KeanuContext
from keanu.net import BayesNet
from keanu.vertex.base import Vertex
from typing import Union, Optional, Tuple
k = KeanuContext()
java_import(k.jvm_view(), "io.improbable.keanu.algorithms.variational.optimizer.gradient.GradientOptimizer")
java_import(k.jvm_view(), "io.improbable.keanu.algorithms.variational.optimizer.nongradient.NonGradientOptimizer")
java_import(k.jvm_view(), "io.improbable.keanu.algorithms.variational.optimizer.KeanuOptimizer")
class Optimizer:
def __init__(self, optimizer: JavaObject, net: Union[BayesNet, Vertex]) -> None:
self.optimizer = optimizer
self.net = net
def max_a_posteriori(self) -> float:
return self.optimizer.maxAPosteriori()
def max_likelihood(self) -> float:
return self.optimizer.maxLikelihood()
@staticmethod
def _build_bayes_net(factory_class: JavaClass,
net: Union[BayesNet, Vertex]) -> Tuple[JavaObject, Union[BayesNet, Vertex]]:
if not (isinstance(net, BayesNet) or isinstance(net, Vertex)):
raise TypeError("net must be a Vertex or a BayesNet. Was given {}".format(type(net)))
from typing import Union, Optional, Tuple
from py4j.java_gateway import java_import, JavaObject, JavaClass
from keanu.base import JavaObjectWrapper
from keanu.context import KeanuContext
from keanu.net import BayesNet
from keanu.tensor import Tensor
from keanu.vartypes import numpy_types
from keanu.vertex.base import Vertex
k = KeanuContext()
java_import(
k.jvm_view(),
"io.improbable.keanu.algorithms.variational.optimizer.gradient.GradientOptimizer"
)
java_import(
k.jvm_view(),
"io.improbable.keanu.algorithms.variational.optimizer.gradient.ConjugateGradient"
)
java_import(
k.jvm_view(),
"io.improbable.keanu.algorithms.variational.optimizer.RelativeConvergenceChecker"
)
java_import(
k.jvm_view(),
"io.improbable.keanu.algorithms.variational.optimizer.AbsoluteConvergenceChecker"
)
java_import(
k.jvm_view(),
from functools import partial
from collections.abc import Iterable as CollectionsIterable
from keanu import BayesNet
from keanu.base import JavaObjectWrapper
from keanu.context import KeanuContext
from keanu.functional import BiConsumer
from keanu.functional import Consumer
from keanu.functional import JavaIterator
from keanu.vertex import Vertex, cast_to_double_vertex, vertex_constructor_param_types, DoubleProxy, shape_types, \
IntegerProxy, BooleanProxy
from keanu.vertex.label import _VertexLabel
k = KeanuContext()
java_import(k.jvm_view(), "io.improbable.keanu.templating.SequenceBuilder")
java_import(k.jvm_view(), "io.improbable.keanu.vertices.SimpleVertexDictionary")
java_import(k.jvm_view(), "io.improbable.keanu.templating.SequenceItem")
java_import(k.jvm_view(), "io.improbable.keanu.templating.SequenceLoader")
class SequenceItem(JavaObjectWrapper):
def add(self, vertex: Vertex, label: Optional[str] = None) -> None:
if label is None:
self.unwrap().add(vertex.unwrap())
else:
self.unwrap().add(_VertexLabel(label).unwrap(), vertex.unwrap())
def get(self, label: str) -> Vertex:
return Vertex._from_java_vertex(self.unwrap().get(_VertexLabel(label).unwrap()))
from typing import Set, Iterable, Union
from py4j.java_gateway import java_import
from keanu.base import JavaObjectWrapper
from keanu.context import KeanuContext
from keanu.vertex import Vertex
k = KeanuContext()
java_import(k.jvm_view(), "io.improbable.keanu.algorithms.mcmc.proposal.AcceptanceRateTracker")
proposal_listener_types = Union['AcceptanceRateTracker']
class AcceptanceRateTracker(JavaObjectWrapper):
def __init__(self) -> None:
super(AcceptanceRateTracker, self).__init__(k.jvm_view().AcceptanceRateTracker())
def get_acceptance_rate(self, vertex: Vertex) -> float:
return self.unwrap().getAcceptanceRate(vertex.unwrap().getId())
from py4j.java_gateway import java_import, JavaObject
from keanu.context import KeanuContext
from keanu.net import BayesNet
from keanu.vertex.base import Vertex
from typing import Union, Optional, Tuple
k = KeanuContext()
java_import(
k.jvm_view(),
"io.improbable.keanu.algorithms.variational.optimizer.gradient.GradientOptimizer"
)
java_import(
k.jvm_view(),
"io.improbable.keanu.algorithms.variational.optimizer.nongradient.NonGradientOptimizer"
)
class Optimizer:
def __init__(self, optimizer: JavaObject, net: Union[BayesNet,
Vertex]) -> None:
self.optimizer = optimizer
self.net = net
def max_a_posteriori(self) -> float:
return self.optimizer.maxAPosteriori()
def max_likelihood(self) -> float:
return self.optimizer.maxLikelihood()
@staticmethod