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