コード例 #1
0
ファイル: test_mcmc_api.py プロジェクト: zeta1999/pyro
def normal_normal_model(data):
    x = torch.tensor([0.0])
    y = pyro.sample('y', dist.Normal(x, torch.ones(data.shape)))
    pyro.sample('obs', dist.Normal(y, torch.tensor([1.0])), obs=data)
    return y
コード例 #2
0
ファイル: minipyro.py プロジェクト: zyxue/pyro
 def guide(data):
     guide_loc = pyro.param("guide_loc", torch.tensor(0.))
     guide_scale = pyro.param("guide_scale_log", torch.tensor(0.)).exp()
     pyro.sample("loc", dist.Normal(guide_loc, guide_scale))
コード例 #3
0
ファイル: regression_1.py プロジェクト: henrishi/bm_model
 def __init__(self, in_features, out_features):
     super().__init__()
     self.linear = PyroModule[nn.Linear](in_features, out_features)
     self.linear.weight = PyroSample(dist.Normal(0., 1.).expand([out_features, in_features]).to_event(2))
     self.linear.bias = PyroSample(dist.Normal(0., 10.).expand([out_features]).to_event(1))
コード例 #4
0
ファイル: test_inference.py プロジェクト: jamestwebber/pyro
 def model():
     pyro.sample("x", dist.Normal(-0.2, 1.2))
     pyro.sample("y", dist.Normal(0.2, 0.7))
コード例 #5
0
ファイル: prob.py プロジェクト: psavine42/juststuff
def scale(guess):
    weight = pyro.sample("weight", dist.Normal(guess, 1.0))
    return pyro.sample("measurement", dist.Normal(weight, 0.75))
コード例 #6
0
ファイル: test_primitives.py プロジェクト: zeta1999/pyro
def test_observe_warn():
    with pytest.warns(RuntimeWarning):
        pyro.sample("x", dist.Normal(0, 1), obs=torch.tensor(0.))
コード例 #7
0
 def model():
     with pyro.plate("J", size, subsample_size=subsample_size):
         pyro.sample("x", dist.Normal(0, 1))
コード例 #8
0
 def model(num_particles):
     p = pyro.param("p")
     with pyro.plate("num_particles", num_particles, dim=-2):
         z = pyro.sample("z", dist.Bernoulli(p))
         with pyro.plate("data", 3):
             pyro.sample("x", dist.Normal(z, 1.), obs=data)
コード例 #9
0
 def model():
     x = pyro.sample("x", dist.Categorical(torch.ones(3)))
     with pyro.plate("data", len(data)):
         pyro.sample("obs", dist.Normal(x.float(), 1), obs=data)
コード例 #10
0
def model(data, params):
    # initialize data
    N = data["N"]
    n_age = data["n_age"]
    n_eth = data["n_eth"]
    age = data["age"].long() - 1
    eth = data["eth"].long() - 1
    x = data["x"]
    y = data["y"]

    # init parameters
    sigma_a1 = params["sigma_a1"]
    sigma_a2 = params["sigma_a2"]
    sigma_b1 = params["sigma_b1"]
    sigma_b2 = params["sigma_b2"]
    sigma_c = params["sigma_c"]
    sigma_d = params["sigma_d"]
    sigma_y = params["sigma_y"]

    mu_a1 = pyro.sample('mu_a1', dist.Normal(0., 1.))
    mu_a2 = pyro.sample('mu_a2', dist.Normal(0., 1.))
    mu_b1 = pyro.sample('mu_b1', dist.Normal(0., 1.))
    mu_b2 = pyro.sample('mu_b2', dist.Normal(0., 1.))
    mu_c = pyro.sample('mu_c', dist.Normal(0., 1.))
    mu_d = pyro.sample('mu_d', dist.Normal(0., 1.))
    plate_a = pyro.plate("as", n_eth, dim=-2)
    plate_b = pyro.plate("bs", n_age, dim=-1)

    with plate_a:
        a1 = pyro.sample('a1', dist.Normal(10 * mu_a1, sigma_a1))
        a2 = pyro.sample('a2', dist.Normal(10 * mu_a2, sigma_a2))
    with plate_b:
        b1 = pyro.sample('b1', dist.Normal(10 * mu_b1, sigma_b1))
        b2 = pyro.sample('b2', dist.Normal(0.1 * mu_b2, sigma_b2))

    with plate_a, plate_b:
        c = pyro.sample('c', dist.Normal(10. * mu_c, sigma_c))
        d = pyro.sample('d', dist.Normal(0.1 * mu_d, sigma_d))

    with pyro.plate("data", N):
        y_hat = a1[..., eth, :].squeeze(-1) + a2[..., eth, :].squeeze(-1) * x + b1[..., age].squeeze() + b2[..., age].squeeze() * \
                x + c[..., eth, age] + d[..., eth, age] * x

        # A hack to make dimensions broadcast correctly when there is an IW plate
        if len(a1.size()) > 2:
            y_hat = y_hat.unsqueeze(-2)

        pyro.sample('y', dist.Normal(y_hat, sigma_y), obs=y)
コード例 #11
0
 def model(subsample_size):
     with pyro.iarange("data", len(data), subsample_size) as ind:
         x = data[ind]
         z = pyro.sample("z", dist.Normal(ng_zeros(len(x)), ng_ones(len(x)),
                                          reparameterized=reparameterized))
         pyro.observe("x", dist.Normal(z, ng_ones(len(x)), reparameterized=reparameterized), x)
コード例 #12
0
 def model(data):
     mu = pyro.sample('mu', dist.Normal(0., 1.))
     sigma = pyro.sample('sigma', dist.HalfCauchy(5.))
     with pyro.plate('observe_data'):
         pyro.sample('obs', dist.Normal(mu, sigma), obs=data)
コード例 #13
0
ファイル: linear.py プロジェクト: MainN/diploma
def linear(xes, yes):
    slope = pyro.sample("slope", dist.Normal(5, 10))
    intercept = pyro.sample("intercept", dist.Normal(0, 10))
    var = pyro.sample("var", dist.InverseGamma(3, 0.1))
    x = slope * xes
    return slope
コード例 #14
0
 def forward(self, observations={"y1": 0, "y2": 0}):
     pyro.module("guide", self)
     summed_obs = observations["y1"] + observations["y2"]
     mean = self.linear(summed_obs.view(1, 1))[0, 0]
     pyro.sample("x", dist.Normal(mean, self.std))
コード例 #15
0
def model(x, y):
    a = pyro.sample('a', dist.Normal(0., 5.))
    b = pyro.sample('b', dist.Normal(0., 5.))
    y = pyro.sample('y', dist.Normal(a * x + b, 1.), obs=y)
    return y
コード例 #16
0
ファイル: test_discrete_cosine.py プロジェクト: zeta1999/pyro
 def model():
     with pyro.plate_stack("plates", shape[:dim]):
         with pyro.plate("particles", 10000):
             pyro.sample(
                 "x",
                 dist.Normal(loc, scale).expand(shape).to_event(-dim))
コード例 #17
0
ファイル: test_primitives.py プロジェクト: zeta1999/pyro
def test_sample_ok():
    x = pyro.sample("x", dist.Normal(0, 1))
    assert isinstance(x, torch.Tensor)
    assert x.shape == ()
コード例 #18
0
 def get_posterior(self, *args, **kwargs):
     """
     Returns a diagonal Normal posterior distribution.
     """
     return dist.Normal(self.loc, self.scale).to_event(1)
コード例 #19
0
def model_with_param():
    x = pyro.param("x", torch.tensor(1.))
    pyro.sample("y", dist.Normal(x, 1))
コード例 #20
0
def perfect_guide(measurement=9.5):
    mean, std = true_mean_std(guess, measurement)
    return lambda guess: pyro.sample("weight",  dist.Normal(mean, std))
コード例 #21
0
 def model(data):
     loc = pyro.param("loc", constant(0.0))
     scale = pyro.param("scale", constant(1.0), constraint=constraints.positive)
     pyro.sample("x", dist.Normal(loc, scale).expand_by(data.shape).to_event(1), obs=data)
コード例 #22
0
def perfect_intervention_guide(guess):
    return pyro.sample("weight", dist.Normal(guess, 1))
コード例 #23
0
def init_vector(name, dims=None):
    return pyro.sample(
        name,
        dist.Normal(torch.zeros(dims), 0.2 * torch.ones(dims)).to_event(1))
コード例 #24
0
def scale_parametrized_guide(guess):
    a = pyro.param("a", torch.tensor(1.))  # guess is a required param but you don't need to use it
    # a = pyro.param("a", torch.tensor(guess))  # not necessary to use the guess here
    b = pyro.param("b", torch.tensor(1.), constraint=constraints.positive)
    return pyro.sample("weight", dist.Normal(a, b))
コード例 #25
0
ファイル: minipyro.py プロジェクト: zyxue/pyro
 def model(data):
     loc = pyro.sample("loc", dist.Normal(0., 1.))
     with pyro.plate("data", len(data), dim=-1):
         pyro.sample("obs", dist.Normal(loc, 1.), obs=data)
コード例 #26
0
def scale(guess):
    weight = pyro.sample("weight", dist.Normal(guess, 1.))
    measure = pyro.sample("measure", dist.Normal(weight, 0.75))
    return guess, weight, measure
def model(data):
    latent = named.Object("latent")
    latent.z.sample_(dist.Normal(0.0, 1.0))
    model_recurse(data, latent)
コード例 #28
0
def scale_obs(guess, measurement=9.5):  # equivalent to conditioned_scale above
    weight = pyro.sample("weight", dist.Normal(guess, 1.))
     # here we condition on measurement == 9.5
    measure = pyro.sample("measure", dist.Normal(weight, 0.75), obs=measurement)
    return guess, weight, measure
コード例 #29
0
ファイル: minimal.py プロジェクト: cweniger/pyrofit-core
def linear(a:Yaml, b:Yaml, x:Yaml):
    pyro.sample("y", dist.Normal(a + b*x, 1.0))
コード例 #30
0
def model(prior_mean, observations={"x1": 0, "x2": 0}):
    x = pyro.sample("z", dist.Normal(prior_mean, torch.tensor(5**0.5)))
    y1 = pyro.sample("x1", dist.Normal(x, torch.tensor(2**0.5)), obs=observations["x1"])
    y2 = pyro.sample("x2", dist.Normal(x, torch.tensor(2**0.5)), obs=observations["x2"])
    return x