def test_can_get_vertices_from_bayes_net(get_method: str, latent: bool,
observed: bool, continuous: bool,
discrete: bool) -> None:
gamma = Gamma(1., 1.)
gamma.observe(0.5)
poisson = Poisson(gamma)
cauchy = Cauchy(gamma, 1.)
assert gamma.is_observed()
assert not poisson.is_observed()
assert not cauchy.is_observed()
net = BayesNet([gamma, poisson, cauchy])
vertex_ids = [vertex.get_id() for vertex in getattr(net, get_method)()]
if observed and continuous:
assert gamma.get_id() in vertex_ids
if latent and discrete:
assert poisson.get_id() in vertex_ids
if latent and continuous:
assert cauchy.get_id() in vertex_ids
assert len(vertex_ids) == (observed and continuous) + (
latent and discrete) + (latent and continuous)
def test_probe_for_non_zero_probability_from_bayes_net() -> None:
gamma = Gamma(1., 1.)
poisson = Poisson(gamma)
net = BayesNet([poisson, gamma])
assert not gamma.has_value()
assert not poisson.has_value()
net.probe_for_non_zero_probability(100, KeanuRandom())
assert gamma.has_value()
assert poisson.has_value()
def model(self) -> Model:
start_year, end_year = (self._data.index.min(), self._data.index.max())
with Model() as m:
m.switchpoint = UniformInt(start_year, end_year + 1)
m.early_rate = Exponential(1.0)
m.late_rate = Exponential(1.0)
m.years = np.array(self._data.index)
m.rates = If(m.switchpoint > m.years, m.early_rate, m.late_rate)
m.disasters = Poisson(m.rates)
return m
def create_time_step(sequence_item):
x_previous = sequence_item.add_double_proxy_for(x_label)
x = Exponential(x_previous)
y = Poisson(x)
sequence_item.add(x, label=x_label)
sequence_item.add(y, label=y_label)
assert type(result) == Double
assert result.unwrap().getClass().getSimpleName() == "WhereVertex"
@pytest.mark.parametrize("predicate", [
True,
np.array([True, False]),
pd.Series([True, False]),
Bernoulli(0.5),
Const(np.array([True, False]))
])
@pytest.mark.parametrize("data", [
1,
np.array([1, 2]),
pd.Series([1, 2]),
Poisson(1),
Const(np.array([1, 2]))
])
def test_you_can_create_an_integer_valued_if(
predicate: Union[tensor_arg_types, Vertex],
data: Union[tensor_arg_types, Vertex]) -> None:
thn = data
els = data
result = If(predicate, thn, els)
assert type(result) == Integer
assert result.unwrap().getClass().getSimpleName() == "WhereVertex"
@pytest.mark.parametrize("predicate", [
True,
np.array([True, False]),
def test_you_can_create_a_double_valued_if(predicate: Union[tensor_arg_types, Vertex],
data: Union[tensor_arg_types, Vertex]) -> None:
thn = data
els = data
result = If(predicate, thn, els)
assert type(result) == Double
assert result.unwrap().getClass().getSimpleName() == "DoubleIfVertex"
@pytest.mark.parametrize(
"predicate",
[True, np.array([True, False]),
pd.Series([True, False]),
Bernoulli(0.5),
Const(np.array([True, False]))])
@pytest.mark.parametrize("data", [1, np.array([1, 2]), pd.Series([1, 2]), Poisson(1), Const(np.array([1, 2]))])
def test_you_can_create_an_integer_valued_if(predicate: Union[tensor_arg_types, Vertex],
data: Union[tensor_arg_types, Vertex]) -> None:
thn = data
els = data
result = If(predicate, thn, els)
assert type(result) == Integer
assert result.unwrap().getClass().getSimpleName() == "IntegerIfVertex"
@pytest.mark.parametrize(
"predicate",
[True, np.array([True, False]),
pd.Series([True, False]),
Bernoulli(0.5),
Const(np.array([True, False]))])