Exemple #1
0
    def model(self, x):
        x_size = x.size(0)

        # sample the global weights
        with pyro.iarange("w_top_iarange", self.top_width * self.mid_width):
            w_top = pyro.sample("w_top", Gamma(self.alpha_w, self.beta_w))
        with pyro.iarange("w_mid_iarange", self.mid_width * self.bottom_width):
            w_mid = pyro.sample("w_mid", Gamma(self.alpha_w, self.beta_w))
        with pyro.iarange("w_bottom_iarange",
                          self.bottom_width * self.image_size):
            w_bottom = pyro.sample("w_bottom", Gamma(self.alpha_w,
                                                     self.beta_w))

        # sample the local latent random variables
        # (the iarange encodes the fact that the z's for different datapoints are conditionally independent)
        with pyro.iarange("data", x_size):
            z_top = pyro.sample(
                "z_top",
                Gamma(self.alpha_z,
                      self.beta_z).expand([self.top_width]).independent(1))
            mean_mid = torch.mm(z_top,
                                w_top.reshape(self.top_width, self.mid_width))
            z_mid = pyro.sample(
                "z_mid",
                Gamma(self.alpha_z, self.beta_z / mean_mid).independent(1))
            mean_bottom = torch.mm(
                z_mid, w_mid.view(self.mid_width, self.bottom_width))
            z_bottom = pyro.sample(
                "z_bottom",
                Gamma(self.alpha_z, self.beta_z / mean_bottom).independent(1))
            mean_obs = torch.mm(
                z_bottom, w_bottom.view(self.bottom_width, self.image_size))

            # observe the data using a poisson likelihood
            pyro.sample('obs', Poisson(mean_obs).independent(1), obs=x)
Exemple #2
0
 def guide(subsample):
     loc = pyro.param("loc", lambda: torch.zeros(len(data), requires_grad=True))
     scale = pyro.param("scale", lambda: torch.tensor([1.0], requires_grad=True))
     with pyro.iarange("particles", num_particles):
         with pyro.iarange("data", len(data), subsample_size, subsample) as ind:
             loc_ind = loc[ind].unsqueeze(-1).expand(-1, num_particles)
             pyro.sample("z", Normal(loc_ind, scale))
Exemple #3
0
 def model():
     with pyro.iarange("particles", num_particles):
         pyro.sample("x", dist.Bernoulli(p).expand_by([num_particles]))
         with pyro.iarange("outer", outer_dim):
             pyro.sample("y", dist.Bernoulli(p).expand_by([outer_dim, num_particles]))
             for i in pyro.irange("inner", inner_dim):
                 pyro.sample("z_{}".format(i), dist.Bernoulli(p).expand_by([outer_dim, num_particles]))
Exemple #4
0
    def model(self):
        # register PyTorch module `decoder` with Pyro
        pyro.module("decoder", self.decoder)
        # Setup hyperparameters for prior p(z)
        z_mu = ng_zeros([self.n_samples, self.n_latent])
        z_sigma = ng_ones([self.n_samples, self.n_latent])
        # sample from prior
        z = pyro.sample("latent", dist.normal, z_mu, z_sigma)
        # decode the latent code z
        z_adj = self.decoder(z)

        # Subsampling
        if self.subsampling:
            with pyro.iarange("data",
                              self.n_subsample,
                              subsample=self.sample()) as ind:
                pyro.observe('obs', dist.bernoulli,
                             self.adj_labels.view(1, -1)[0][ind],
                             z_adj.view(1, -1)[0][ind])
        # Reweighting
        else:
            with pyro.iarange("data"):
                pyro.observe('obs',
                             weighted_bernoulli,
                             self.adj_labels.view(1, -1),
                             z_adj.view(1, -1),
                             weight=self.pos_weight)
Exemple #5
0
def model(y,x,N):
    w = pyro.sample('w'.format(''), dist.Beta(Variable(26.072914040168385*torch.ones([amb(1)])),Variable((42.3120851154)*torch.ones([amb(1)]))))
    with pyro.iarange('b_range_'.format(''), N):
        b = pyro.sample('b'.format(''), dist.Gamma(Variable((5.63887222899)*torch.ones([amb(N)])),Variable((40.1978121928)*torch.ones([amb(N)]))))
    with pyro.iarange('p_range_'.format(''), N):
        p = pyro.sample('p'.format(''), dist.Beta(Variable((52.1419233118)*torch.ones([amb(N)])),Variable((83.6618285099)*torch.ones([amb(N)]))))
    pyro.sample('obs__100'.format(), dist.Beta(w*x+b,p), obs=y)
Exemple #6
0
 def model():
     p = torch.tensor([0.5], requires_grad=True)
     with pyro.iarange("iarange_outer", 10, 5) as ind_outer:
         pyro.sample("x", dist.Bernoulli(p).expand_by([len(ind_outer), 1]))
         with pyro.iarange("iarange_inner", 11, 6) as ind_inner:
             pyro.sample("y", dist.Bernoulli(p).expand_by([len(ind_inner)]))
             pyro.sample("z", dist.Bernoulli(p).expand_by([len(ind_outer), len(ind_outer)]))  # error here
Exemple #7
0
 def model():
     with pyro.iarange("num_particles", 10, dim=-3):
         with pyro.iarange("components", 2, dim=-1):
             p = pyro.sample("p", dist.Beta(torch.tensor(1.1), torch.tensor(1.1)))
             assert p.shape == torch.Size((10, 1, 2))
         with pyro.iarange("data", data.shape[0], dim=-2):
             pyro.sample("obs", dist.Bernoulli(p), obs=data)
Exemple #8
0
 def guide():
     q = pyro.param("q")
     with pyro.iarange("particles", num_particles):
         pyro.sample("y", dist.Bernoulli(q).expand_by([num_particles]),
                     infer={"enumerate": enumerate1})
         with pyro.iarange("iarange", iarange_dim):
             pyro.sample("z", dist.Bernoulli(q).expand_by([iarange_dim, num_particles]),
                         infer={"enumerate": enumerate2})
Exemple #9
0
 def guide():
     p = pyro.param("p", Variable(torch.Tensor([0.5]), requires_grad=True))
     with pyro.iarange("iarange_0", 10, 5) as ind1:
         with pyro.iarange("iarange_1", 10, 5) as ind2:
             pyro.sample("x",
                         dist.bernoulli,
                         p,
                         batch_size=len(ind1) * len(ind2))
Exemple #10
0
 def model():
     p = Variable(torch.Tensor([0.5]))
     with pyro.iarange("iarange_0", 10, 5) as ind1:
         with pyro.iarange("iarange_1", 10, 5) as ind2:
             pyro.sample("x",
                         dist.bernoulli,
                         p,
                         batch_size=len(ind1) * len(ind2))
Exemple #11
0
 def model():
     with pyro.iarange("num_particles", 10, dim=-3):
         with pyro.iarange("components", 2, dim=-1):
             p = pyro.sample(
                 "p", dist.Beta(torch.tensor(1.1), torch.tensor(1.1)))
             assert p.shape == torch.Size((10, 1, 2))
         with pyro.iarange("data", data.shape[0], dim=-2):
             pyro.sample("obs", dist.Bernoulli(p), obs=data)
Exemple #12
0
 def model(loc, cov):
     x = pyro.param("x", torch.randn(2))
     y = pyro.param("y", torch.randn(3, 2))
     z = pyro.param("z", torch.randn(4, 2).abs(), constraint=constraints.greater_than(-1))
     pyro.sample("obs_x", dist.MultivariateNormal(loc, cov), obs=x)
     with pyro.iarange("y_iarange", 3):
         pyro.sample("obs_y", dist.MultivariateNormal(loc, cov), obs=y)
     with pyro.iarange("z_iarange", 4):
         pyro.sample("obs_z", dist.MultivariateNormal(loc, cov), obs=z)
Exemple #13
0
 def model():
     p = torch.tensor([0.5], requires_grad=True)
     with pyro.iarange("iarange_outer", 10, 5) as ind_outer:
         pyro.sample("x", dist.Bernoulli(p).expand_by([len(ind_outer), 1]))
         with pyro.iarange("iarange_inner", 11, 6) as ind_inner:
             pyro.sample("y", dist.Bernoulli(p).expand_by([len(ind_inner)]))
             pyro.sample("z",
                         dist.Bernoulli(p).expand_by([len(ind_inner),
                                                      1]))  # error here
Exemple #14
0
    def guide():
        loc = pyro.param("loc", torch.zeros(len(data)))
        scale = pyro.param("scale", torch.tensor([1.]))

        pyro.sample("nuisance_c", Normal(4, 5))
        with pyro.iarange("particles", num_particles, dim=-2):
            with pyro.iarange("data", len(data), dim=-1):
                pyro.sample("z", Normal(loc, scale))
        pyro.sample("nuisance_b", Normal(2, 3))
        pyro.sample("nuisance_a", Normal(0, 1))
Exemple #15
0
 def model():
     p = torch.tensor(0.5, requires_grad=True)
     iarange_outer = pyro.iarange("iarange_outer", 10, 5, dim=-1)
     iarange_inner = pyro.iarange("iarange_inner", 11, 6, dim=-2)
     with iarange_outer as ind_outer:
         pyro.sample("x", dist.Bernoulli(p).expand_by([len(ind_outer)]))
     with iarange_inner as ind_inner:
         pyro.sample("y", dist.Bernoulli(p).expand_by([len(ind_inner), 1]))
     with iarange_outer as ind_outer, iarange_inner as ind_inner:
         pyro.sample("z", dist.Bernoulli(p).expand_by([len(ind_inner), len(ind_outer)]))
Exemple #16
0
 def guide():
     p = pyro.param("p", Variable(torch.Tensor([0.5]), requires_grad=True))
     for i in pyro.irange("irange0", 2):
         pyro.sample("x_%d" % i, dist.bernoulli, p)
         if i == 0:
             for j in pyro.irange("irange1", 2):
                 with pyro.iarange("iarange1", 10, 5) as ind:
                     pyro.sample("y_%d" % j, dist.bernoulli, p, batch_size=len(ind))
         elif i == 1:
             with pyro.iarange("iarange1", 10, 5) as ind:
                 pyro.sample("z", dist.bernoulli, p, batch_size=len(ind))
Exemple #17
0
def xy_model():
    d = dist.Bernoulli(0.5)
    x_axis = pyro.iarange('x_axis', 2, dim=-1)
    y_axis = pyro.iarange('y_axis', 3, dim=-2)
    pyro.sample('b', d)
    with x_axis:
        pyro.sample('bx', d.expand_by([2]))
    with y_axis:
        pyro.sample('by', d.expand_by([3, 1]))
    with x_axis, y_axis:
        pyro.sample('bxy', d.expand_by([3, 2]))
Exemple #18
0
def xy_model():
    d = dist.Bernoulli(0.5)
    x_axis = pyro.iarange('x_axis', 2, dim=-1)
    y_axis = pyro.iarange('y_axis', 3, dim=-2)
    pyro.sample('b', d)
    with x_axis:
        pyro.sample('bx', d.expand_by([2]))
    with y_axis:
        pyro.sample('by', d.expand_by([3, 1]))
    with x_axis, y_axis:
        pyro.sample('bxy', d.expand_by([3, 2]))
Exemple #19
0
    def model():
        particles_iarange = pyro.iarange("particles", num_particles, dim=-2)
        data_iarange = pyro.iarange("data", len(data), dim=-1)

        pyro.sample("nuisance_a", Normal(0, 1))
        with particles_iarange, data_iarange:
            z = pyro.sample("z", Normal(0, 1))
        pyro.sample("nuisance_b", Normal(2, 3))
        with data_iarange, particles_iarange:
            pyro.sample("x", Normal(z, 1), obs=data)
        pyro.sample("nuisance_c", Normal(4, 5))
Exemple #20
0
 def model(loc, cov):
     x = pyro.param("x", torch.randn(2))
     y = pyro.param("y", torch.randn(3, 2))
     z = pyro.param("z",
                    torch.randn(4, 2).abs(),
                    constraint=constraints.greater_than(-1))
     pyro.sample("obs_x", dist.MultivariateNormal(loc, cov), obs=x)
     with pyro.iarange("y_iarange", 3):
         pyro.sample("obs_y", dist.MultivariateNormal(loc, cov), obs=y)
     with pyro.iarange("z_iarange", 4):
         pyro.sample("obs_z", dist.MultivariateNormal(loc, cov), obs=z)
Exemple #21
0
 def guide():
     q = pyro.param("q")
     with pyro.iarange("particles", num_particles):
         pyro.sample("x", dist.Bernoulli(q).expand_by([num_particles]),
                     infer={"enumerate": enumerate1})
         with pyro.iarange("outer", outer_dim):
             pyro.sample("y", dist.Bernoulli(q).expand_by([outer_dim, num_particles]),
                         infer={"enumerate": enumerate2})
             for i in pyro.irange("inner", inner_dim):
                 pyro.sample("z_{}".format(i), dist.Bernoulli(q).expand_by([outer_dim, num_particles]),
                             infer={"enumerate": enumerate3})
Exemple #22
0
 def model():
     p = Variable(torch.Tensor([0.5]))
     for i in pyro.irange("irange0", 2):
         pyro.sample("x_%d" % i, dist.bernoulli, p)
         if i == 0:
             for j in pyro.irange("irange1", 2):
                 with pyro.iarange("iarange1", 10, 5) as ind:
                     pyro.sample("y_%d" % j, dist.bernoulli, p, batch_size=len(ind))
         elif i == 1:
             with pyro.iarange("iarange1", 10, 5) as ind:
                 pyro.sample("z", dist.bernoulli, p, batch_size=len(ind))
Exemple #23
0
 def model():
     pyro.sample("w", dist.Bernoulli(0.5), infer={'enumerate': 'parallel'})
     x_iarange = pyro.iarange("x_iarange", 10, 5, dim=-1)
     y_iarange = pyro.iarange("y_iarange", 11, 6, dim=-2)
     pyro.sample("a", dist.Bernoulli(0.5))
     with x_iarange:
         pyro.sample("b", dist.Bernoulli(0.5).expand_by([5]))
     with y_iarange:
         # Note that it is difficult to check that c does not depend on b.
         pyro.sample("c", dist.Bernoulli(0.5).expand_by([6, 1]))
     with x_iarange, y_iarange:
         pyro.sample("d", dist.Bernoulli(0.5).expand_by([6, 5]))
Exemple #24
0
 def model():
     d = dist.Bernoulli(p)
     with pyro.iarange("particles", num_particles):
         context1 = pyro.iarange("outer", outer_dim, dim=-2)
         context2 = pyro.iarange("inner", inner_dim, dim=-3)
         pyro.sample("w", d.expand_by([num_particles]))
         with context1:
             pyro.sample("x", d.expand_by([outer_dim, num_particles]))
         with context2:
             pyro.sample("y", d.expand_by([inner_dim, 1, num_particles]))
         with context1, context2:
             pyro.sample("z", d.expand_by([inner_dim, outer_dim, num_particles]))
Exemple #25
0
 def guide():
     d = dist.Bernoulli(pyro.param("q"))
     with pyro.iarange("particles", num_particles):
         context1 = pyro.iarange("outer", outer_dim, dim=-2)
         context2 = pyro.iarange("inner", inner_dim, dim=-3)
         pyro.sample("w", d.expand_by([num_particles]), infer={"enumerate": enumerate1})
         with context1:
             pyro.sample("x", d.expand_by([outer_dim, num_particles]), infer={"enumerate": enumerate2})
         with context2:
             pyro.sample("y", d.expand_by([inner_dim, 1, num_particles]), infer={"enumerate": enumerate3})
         with context1, context2:
             pyro.sample("z", d.expand_by([inner_dim, outer_dim, num_particles]), infer={"enumerate": enumerate4})
Exemple #26
0
 def model():
     pyro.sample("w", dist.Bernoulli(0.5), infer={'enumerate': 'parallel'})
     x_iarange = pyro.iarange("x_iarange", 10, 5, dim=-1)
     y_iarange = pyro.iarange("y_iarange", 11, 6, dim=-2)
     pyro.sample("a", dist.Bernoulli(0.5))
     with x_iarange:
         pyro.sample("b", dist.Bernoulli(0.5).expand_by([5]))
     with y_iarange:
         # Note that it is difficult to check that c does not depend on b.
         pyro.sample("c", dist.Bernoulli(0.5).expand_by([6, 1]))
     with x_iarange, y_iarange:
         pyro.sample("d", dist.Bernoulli(0.5).expand_by([6, 5]))
Exemple #27
0
    def model():
        pyro.sample("w", dist.Bernoulli(0.5), infer={'enumerate': 'parallel'})

        with pyro.iarange("non_enum", 2):
            a = pyro.sample("a", dist.Bernoulli(0.5).expand_by([2]),
                            infer={'enumerate': None})

        p = (1.0 + a.sum(-1)) / (2.0 + a.size(0))  # introduce dependency of b on a

        with pyro.iarange("enum_1", 3):
            pyro.sample("b", dist.Bernoulli(p).expand_by([3]),
                        infer={'enumerate': enumerate_})
Exemple #28
0
 def model():
     p = torch.tensor(0.5, requires_grad=True)
     iarange_outer = pyro.iarange("iarange_outer", 10, 5, dim=-1)
     iarange_inner = pyro.iarange("iarange_inner", 11, 6, dim=-2)
     with iarange_outer as ind_outer:
         pyro.sample("x", dist.Bernoulli(p).expand_by([len(ind_outer)]))
     with iarange_inner as ind_inner:
         pyro.sample("y", dist.Bernoulli(p).expand_by([len(ind_inner), 1]))
     with iarange_outer as ind_outer, iarange_inner as ind_inner:
         pyro.sample(
             "z",
             dist.Bernoulli(p).expand_by([len(ind_inner),
                                          len(ind_outer)]))
Exemple #29
0
def guide(y,x,N):
    arg_1 = torch.nn.Softplus()(pyro.param('arg_1', Variable(torch.ones((amb(1))), requires_grad=True)))
    arg_2 = torch.nn.Softplus()(pyro.param('arg_2', Variable(torch.ones((amb(1))), requires_grad=True)))
    w = pyro.sample('w'.format(''), dist.Beta(arg_1,arg_2))
    arg_3 = torch.nn.Softplus()(pyro.param('arg_3', Variable(torch.ones((amb(N))), requires_grad=True)))
    arg_4 = torch.nn.Softplus()(pyro.param('arg_4', Variable(torch.ones((amb(N))), requires_grad=True)))
    with pyro.iarange('b_prange'):
        b = pyro.sample('b'.format(''), dist.Gamma(arg_3,arg_4))
    arg_5 = torch.nn.Softplus()(pyro.param('arg_5', Variable(torch.ones((amb(N))), requires_grad=True)))
    arg_6 = torch.nn.Softplus()(pyro.param('arg_6', Variable(torch.ones((amb(N))), requires_grad=True)))
    with pyro.iarange('p_prange'):
        p = pyro.sample('p'.format(''), dist.Beta(arg_5,arg_6))
    
    pass
Exemple #30
0
    def model(self, ob, ac, next_ob, reward, game_over):
        network_dist = pyro.random_module('dream_world', self.network, self.prior_dist)
        network = network_dist()
        next_ob_logits, reward_logits, game_over_logits = network(ob, ac)

        next_ob_batch = pyro.iarange('next_ob_batch', next_ob.shape[0], dim=-3)
        next_ob_height = pyro.iarange('next_ob_height', next_ob.shape[1], dim=-2)
        next_ob_width = pyro.iarange('next_ob_width', next_ob.shape[2], dim=-1)
        with next_ob_batch, next_ob_height, next_ob_width:
            next_ob = pyro.sample('next_ob', CustomCategorical(logits=next_ob_logits), obs=next_ob)

        with pyro.iarange('batch', len(ac)):
            reward = pyro.sample('reward', CustomCategorical(logits=reward_logits), obs=reward)
            game_over = pyro.sample('game_over', CustomCategorical(logits=game_over_logits), obs=game_over)
Exemple #31
0
    def model():
        pyro.sample("w", dist.Bernoulli(0.5), infer={'enumerate': 'parallel'})

        with pyro.iarange("non_enum", 2):
            a = pyro.sample("a",
                            dist.Bernoulli(0.5).expand_by([2]),
                            infer={'enumerate': None})

        p = (1.0 + a.sum(-1)) / (2.0 + a.size(0)
                                 )  # introduce dependency of b on a

        with pyro.iarange("enum_1", 3):
            pyro.sample("b",
                        dist.Bernoulli(p).expand_by([3]),
                        infer={'enumerate': enumerate_})
Exemple #32
0
def iarange_reuse_model_guide(include_obs=True, dim1=3, dim2=2):
    p0 = torch.tensor(math.exp(-0.40 - include_obs * 0.2), requires_grad=True)
    p1 = torch.tensor(math.exp(-0.33 - include_obs * 0.1), requires_grad=True)
    pyro.sample("a1", dist.Bernoulli(p0 * p1))
    my_iarange1 = pyro.iarange("iarange1", dim1)
    my_iarange2 = pyro.iarange("iarange2", dim2)
    with my_iarange1 as ind1:
        with my_iarange2 as ind2:
            pyro.sample("c1", dist.Bernoulli(p1).expand_by([len(ind2), len(ind1)]))
    pyro.sample("b1", dist.Bernoulli(p0 * p1))
    with my_iarange2 as ind2:
        with my_iarange1 as ind1:
            c2 = pyro.sample("c2", dist.Bernoulli(p1).expand_by([len(ind2), len(ind1)]))
            if include_obs:
                pyro.sample("obs", dist.Bernoulli(c2), obs=torch.ones(c2.size()))
Exemple #33
0
def model(y, x, N):
    w = pyro.sample(
        'w'.format(''),
        dist.Exponential(Variable((37.4790187832) * torch.ones([amb(1)]))))
    with pyro.iarange('b_range_'.format(''), N):
        b = pyro.sample(
            'b'.format(''),
            dist.Exponential(
                Variable(31.494555467732837 * torch.ones([amb(N)]))))
    with pyro.iarange('p_range_'.format(''), N):
        p = pyro.sample(
            'p'.format(''),
            dist.Normal(Variable(55.43075391668968 * torch.ones([amb(N)])),
                        Variable((61.3521758404) * torch.ones([amb(N)]))))
    pyro.sample('obs__100'.format(), dist.LogNormal(w * x + b, p), obs=y)
Exemple #34
0
def guide(nyear, C, nsite, year):
    arg_1 = pyro.param('arg_1', torch.ones((amb(1))))
    arg_2 = pyro.param('arg_2',
                       torch.ones((amb(1))),
                       constraint=constraints.positive)
    sd_year = pyro.sample('sd_year'.format(''), dist.Normal(arg_1, arg_2))
    arg_3 = pyro.param('arg_3',
                       torch.ones((amb(1))),
                       constraint=constraints.positive)
    arg_4 = pyro.param('arg_4',
                       torch.ones((amb(1))),
                       constraint=constraints.positive)
    sd_alpha = pyro.sample('sd_alpha'.format(''), dist.Gamma(arg_3, arg_4))
    arg_5 = pyro.param('arg_5',
                       torch.ones((amb(1))),
                       constraint=constraints.positive)
    arg_6 = pyro.param('arg_6',
                       torch.ones((amb(1))),
                       constraint=constraints.positive)
    mu = pyro.sample('mu'.format(''), dist.Gamma(arg_5, arg_6))
    arg_7 = pyro.param('arg_7', torch.ones((amb(nsite))))
    arg_8 = pyro.param('arg_8',
                       torch.ones((amb(nsite))),
                       constraint=constraints.positive)
    with pyro.iarange('alpha_prange'):
        alpha = pyro.sample('alpha'.format(''), dist.Normal(arg_7, arg_8))
    arg_9 = pyro.param('arg_9',
                       torch.ones((amb(3))),
                       constraint=constraints.positive)
    arg_10 = pyro.param('arg_10',
                        torch.ones((amb(3))),
                        constraint=constraints.positive)
    with pyro.iarange('beta_prange'):
        beta = pyro.sample('beta'.format(''), dist.Gamma(arg_9, arg_10))
    arg_11 = pyro.param('arg_11',
                        torch.ones((amb(nyear))),
                        constraint=constraints.positive)
    arg_12 = pyro.param('arg_12',
                        torch.ones((amb(nyear))),
                        constraint=constraints.positive)
    with pyro.iarange('eps_prange'):
        eps = pyro.sample('eps'.format(''), dist.Gamma(arg_11, arg_12))
    for i in range(1, nyear + 1):
        pass
    for i in range(1, nyear + 1):
        pass

    pass
Exemple #35
0
 def guide(num_particles):
     q1 = pyro.param("q1", torch.tensor(pi1, requires_grad=True))
     q2 = pyro.param("q2", torch.tensor(pi2, requires_grad=True))
     with pyro.iarange("particles", num_particles):
         z = pyro.sample("z", dist.Normal(q2, 1.0).expand_by([num_particles]))
         zz = torch.exp(z) / (1.0 + torch.exp(z))
         pyro.sample("y", dist.Bernoulli(q1 * zz))
Exemple #36
0
 def model(num_particles):
     with pyro.iarange("particles", num_particles):
         q3 = pyro.param("q3", torch.tensor(pi3, requires_grad=True))
         q4 = pyro.param("q4", torch.tensor(0.5 * (pi1 + pi2), requires_grad=True))
         z = pyro.sample("z", dist.Normal(q3, 1.0).expand_by([num_particles]))
         zz = torch.exp(z) / (1.0 + torch.exp(z))
         pyro.sample("y", dist.Bernoulli(q4 * zz))
Exemple #37
0
 def guide():
     q1 = pyro.param("q1", torch.tensor(pi1, requires_grad=True))
     q2 = pyro.param("q2", torch.tensor(pi2, requires_grad=True))
     with pyro.iarange("particles", num_particles):
         y = pyro.sample("y", dist.Bernoulli(q1).expand_by([num_particles]), infer={"enumerate": enumerate1})
         if include_z:
             pyro.sample("z", dist.Normal(q2 * y + 0.10, 1.0))
Exemple #38
0
def gmm_batch_guide(data):
    with pyro.iarange("data", len(data)) as batch:
        n = len(batch)
        ps = pyro.param("ps", Variable(torch.ones(n, 1) * 0.6, requires_grad=True))
        ps = torch.cat([ps, 1 - ps], dim=1)
        z = pyro.sample("z", dist.Categorical(ps))
        assert z.size() == (n, 2)
Exemple #39
0
 def guide(subsample_size):
     mu = pyro.param("mu", lambda: Variable(torch.zeros(len(data)), requires_grad=True))
     sigma = pyro.param("sigma", lambda: Variable(torch.ones(1), requires_grad=True))
     with pyro.iarange("data", len(data), subsample_size) as ind:
         mu = mu[ind]
         sigma = sigma.expand(subsample_size)
         pyro.sample("z", dist.Normal(mu, sigma, reparameterized=reparameterized))
Exemple #40
0
def gmm_batch_guide(data):
    with pyro.iarange("data", len(data)) as batch:
        n = len(batch)
        probs = pyro.param("probs", torch.tensor(torch.ones(n, 1) * 0.6, requires_grad=True))
        probs = torch.cat([probs, 1 - probs], dim=1)
        z = pyro.sample("z", dist.OneHotCategorical(probs))
        assert z.shape[-2:] == (n, 2)
Exemple #41
0
    def guide(self, y, m, l, x):
        '''
        Define the guide (i.e. variational distribution), q(z| y, x)
        :param y: measurements
        :param x: conditioning variables
        :return: None
        '''

        if self.use_cuda:
            y = y.cuda()
            x = x.cuda()
            m = m.cuda()
            l = l.cuda()

        # register PyTorch module `encoder` with Pyro
        pyro.module("encoder", self.encoder)
        # print(x.is_cuda, y.is_cuda, m)

        yFused = self.sim_measurements(x, 5) * (1 - m) + m * y
        #yFused = y

        with pyro.iarange("data", x.size(0)):

            # use the encoder to get the parameters used to define q(z|y,x)
            z_loc, z_scale = self.encoder.forward(yFused, x)

            # sample the latent code z
            pyro.sample("latent_posterior",
                        dist.Normal(z_loc, z_scale).independent(1))

        self.debug_qty += 1
Exemple #42
0
    def model(self, xs, ys=None):
        # can pass in ys as labels or not pass in anything for unlabelled
        # register PyTorch module `decoder` with Pyro
        pyro.module("decoder", self.decoder)
        # with pyro.plate("data"):
        with pyro.iarange("data", xs.shape[0]):
            # setup hyperparameters for prior p(z)
            z_loc = xs.new_zeros(torch.Size((xs.shape[0], self.z_dim)))
            z_scale = xs.new_ones(torch.Size((xs.shape[0], self.z_dim)))

            # sample from prior (value will be sampled by guide when computing the ELBO)
            zs = pyro.sample("z", dist.Normal(z_loc, z_scale).independent(1))

            # if there is a label y, sample from the constant prior
            # otherwise, observe the value (i.e. score against constant prior)
            # alpha_prior = xs.new_ones(torch.Size((xs.shape[0], self.output_size))) / (1.0*self.output_size)

            # prior is the actual train data label distribution (not uniform)
            alpha_prior = self.prior_probs.repeat(xs.shape[0], 1)

            ys = pyro.sample("y", dist.OneHotCategorical(alpha_prior), obs=ys)

            # decoder outputs mean and sqroot cov, sample from normal
            recon_loc, recon_scale = self.decoder.forward([zs, ys])
            pyro.sample("x",
                        dist.Normal(recon_loc, recon_scale).independent(1),
                        obs=xs.reshape(-1, 1335))
Exemple #43
0
def iarange_model(subsample_size):
    loc = torch.zeros(20)
    scale = torch.ones(20)
    with pyro.iarange('iarange', 20, subsample_size) as batch:
        pyro.sample("x", dist.Normal(loc[batch], scale[batch]))
        result = list(batch.data)
    return result
Exemple #44
0
def pyromodel(x, y):
    priors = {}
    for name, par in model.named_parameters():
        priors[name] = dist.Normal(torch.zeros(*par.shape),
                                   50 * torch.ones(*par.shape)).independent(
                                       par.dim())

        #print("batch shape:", priors[name].batch_shape)
        #print("event shape:", priors[name].event_shape)
        #print("event dim:", priors[name].event_dim)

    bayesian_model = pyro.random_module('bayesian_model', model, priors)
    sampled_model = bayesian_model()
    sigma = pyro.sample('sigma', Uniform(0, 50))
    with pyro.iarange("map", len(x)):
        prediction_mean = sampled_model(x)
        logging.debug(f"prediction_mean: {prediction_mean.shape}")

        if y is not None:
            logging.debug(f"y_data: {y.shape}")

        d_dist = Normal(prediction_mean, sigma).to_event(1)

        if y is not None:
            logging.debug(f"y_data: {y.shape}")

        logging.debug(f"batch shape: {d_dist.batch_shape}")
        logging.debug(f"event shape: {d_dist.event_shape}")
        logging.debug(f"event dim: {d_dist.event_dim}")

        pyro.sample("obs", d_dist, obs=y)

        return prediction_mean
Exemple #45
0
    def guide(self, xs, ys=None):
        """
        The guide corresponds to the following:
        q(y|x) = categorical(alpha(x))              # infer digit from an image
        q(z|x,y) = normal(mu(x,y),sigma(x,y))       # infer handwriting style from an image and the digit
        mu, sigma are given by a neural network `encoder_z`
        alpha is given by a neural network `encoder_y`
        :param xs: a batch of scaled vectors of pixels from an image
        :param ys: (optional) a batch of the class labels i.e.
                   the digit corresponding to the image(s)
        :return: None
        """
        # inform Pyro that the variables in the batch of xs, ys are conditionally independent
        with pyro.iarange("independent"):

            # if the class label (the digit) is not supervised, sample
            # (and score) the digit with the variational distribution
            # q(y|x) = categorical(alpha(x))
            if ys is None:
                alpha = self.encoder_y.forward(xs)
                ys = pyro.sample("y", dist.categorical, alpha)

            # sample (and score) the latent handwriting-style with the variational
            # distribution q(z|x,y) = normal(mu(x,y),sigma(x,y))
            mu, sigma = self.encoder_z.forward([xs, ys])
            zs = pyro.sample("z", dist.normal, mu, sigma)   # noqa: F841
Exemple #46
0
 def guide(self, x):
     # register PyTorch module `encoder` with Pyro
     pyro.module("encoder", self.encoder)
     with pyro.iarange("data", x.size(0)):
         # use the encoder to get the parameters used to define q(z|x)
         z_loc, z_scale = self.encoder.forward(x)
         # sample the latent code z
         pyro.sample("latent", dist.Normal(z_loc, z_scale).independent(1))
Exemple #47
0
 def model():
     pyro.sample("w", dist.Bernoulli(0.5), infer={'enumerate': 'parallel'})
     inner_iarange = pyro.iarange("iarange", 10, 5)
     for i in pyro.irange("irange", 3):
         pyro.sample("y_{}".format(i), dist.Bernoulli(0.5))
         with inner_iarange:
             pyro.sample("x_{}".format(i), dist.Bernoulli(0.5).expand_by([5]),
                         infer={'enumerate': enumerate_})
Exemple #48
0
    def model(data):
        weights = pyro.sample('weights', dist.Dirichlet(0.5 * torch.ones(K)))
        locs = pyro.sample('locs', dist.Normal(0, 10).expand_by([K]).independent(1))
        scale = pyro.sample('scale', dist.LogNormal(0, 1))

        with pyro.iarange('data', len(data)):
            weights = weights.expand(torch.Size((len(data),)) + weights.shape)
            assignment = pyro.sample('assignment', dist.Categorical(weights))
            pyro.sample('obs', dist.Normal(locs[assignment], scale), obs=data)
Exemple #49
0
 def model(self, data):
     decoder = pyro.module('decoder', self.vae_decoder)
     z_mean, z_std = torch.zeros([data.size(0), 20]), torch.ones([data.size(0), 20])
     with pyro.iarange('data', data.size(0)):
         z = pyro.sample('latent', Normal(z_mean, z_std).independent(1))
         img = decoder.forward(z)
         pyro.sample('obs',
                     Bernoulli(img).independent(1),
                     obs=data.reshape(-1, 784))
Exemple #50
0
 def model():
     x_iarange = pyro.iarange("x_iarange", 10, 5, dim=-1)
     y_iarange = pyro.iarange("y_iarange", 11, 6, dim=-2)
     with pyro.iarange("num_particles", 50, dim=-3):
         with x_iarange:
             b = pyro.sample("b", dist.Beta(torch.tensor(1.1), torch.tensor(1.1)))
             assert b.shape == torch.Size((50, 1, 5))
         with y_iarange:
             c = pyro.sample("c", dist.Bernoulli(0.5))
             if enumerate_ == "parallel":
                 assert c.shape == torch.Size((2, 50, 6, 1))
             else:
                 assert c.shape == torch.Size((50, 6, 1))
         with x_iarange, y_iarange:
             d = pyro.sample("d", dist.Bernoulli(b))
             if enumerate_ == "parallel":
                 assert d.shape == torch.Size((2, 1, 50, 6, 5))
             else:
                 assert d.shape == torch.Size((50, 6, 5))
Exemple #51
0
 def model():
     p = pyro.param("p", torch.tensor([0.05, 0.15]))
     probs = pyro.param("probs", torch.tensor([[0.1, 0.2, 0.3, 0.4],
                                               [0.4, 0.3, 0.2, 0.1]]))
     with pyro.iarange("iarange", 2):
         x = pyro.sample("x", dist.Bernoulli(p))
         y = pyro.sample("y", dist.Categorical(probs))
     assert x.size() == (2,)
     assert y.size() == (2,)
     return dict(x=x, y=y)