def test_log_prob(self): mu = ch.Variable(np.array(0.)) sigma = ch.Variable(np.array(1.)) cond_value = ch.Variable(np.array(0.5)) x = StochasticVariable(dist.Normal, mu, sigma) x.condition(cond_value) self.assertEqual(x.log_prob.data, dist.Normal(mu, sigma).log_prob(cond_value).data)
def to_dist_fn(h): loc, scale = h xp = cuda.get_array_module(loc, scale) return distributions.HyperbolicWrapped( distributions.Independent( D.Normal(loc=xp.zeros(shape=scale.shape, dtype=scale.dtype), scale=scale)), functions.pseudo_polar_projection(loc))
def to_dist_fn(h): xp = cuda.get_array_module(h) scale = F.softplus(h[..., n_latent:]) shape = scale.shape[:-1] + (n_latent, ) return distributions.HyperbolicWrapped( distributions.Independent( D.Normal(loc=xp.zeros(shape=shape, dtype=scale.dtype), scale=scale)), functions.pseudo_polar_projection(h[..., :n_latent]))
def to_dist_fn(h): mu, ln_sigma = h xp = cuda.get_array_module(*h) scale = F.softplus(ln_sigma) return distributions.HyperbolicWrapped( distributions.Independent(D.Normal( loc=xp.zeros(shape=scale.shape, dtype=scale.dtype), scale=scale)), functions.pseudo_polar_projection(mu))
def __call__(self, x): h = x for layer in self._hidden_layers: h = F.relu(layer(h)) #for theta = F.sigmoid(self._output_layer(h)) mu = 4*theta[:, 0]-2 sigma = 0.5*theta[:, 1]+self._eps return D.Normal(mu, sigma)
def make_normal_dist(self, is_gpu=False, use_log_scale=False): loc = numpy.random.uniform(-1, 1, self.shape).astype(numpy.float32) if use_log_scale: log_scale = numpy.random.uniform( -1, 1, self.shape).astype(numpy.float32) params = self.encode_params( {"loc": loc, "log_scale": log_scale}, is_gpu) else: scale = numpy.exp( numpy.random.uniform(-1, 1, self.shape)).astype(numpy.float32) params = self.encode_params({"loc": loc, "scale": scale}, is_gpu) return distributions.Normal(**params)
def negative_log_likelihood(self, x, y): pi, mu, log_var = self.get_gaussian_params(x) # Likelihood over different Gaussians y = F.tile(y[:, None, :], (1, self.gaussian_mixtures, 1)) pi = F.tile(F.expand_dims(pi, 2), (1, 1, self.input_dim)) squared_sigma = F.exp(log_var) sigma = F.sqrt(squared_sigma) prob = F.sum(pi * distributions.Normal(mu, sigma).prob(y), axis=1) negative_log_likelihood = -F.log(prob) return F.mean(negative_log_likelihood)
def encode(self, x, **kwargs): # x = self.adapt(x) self.in_shape = x.shape[1:] self.maybe_init(self.in_shape) x_ = x.reshape(-1, self.in_size) mu = self.mu(x_) if kwargs.get('show_shape'): print(f'layer(E{self.name}): in: {x.shape} out: {mu.shape}') if kwargs.get('inference'): return mu # == D.Normal(loc=mu, log_scale=ln_sigma).mean else: ln_sigma = self.ln_sigma(x_) # log(sigma) # return mu, ln_sigma return D.Normal(loc=mu, log_scale=ln_sigma)
def to_dist_fn(h): if ndim == 1: dim_h = h.shape[-1] loc = h[..., :(dim_h // 2)] base_sigma = h[..., (dim_h // 2):] elif ndim == 3: nb_channel = h.shape[-3] loc = h[..., :(nb_channel // 2), :, :] base_sigma = h[..., (nb_channel // 2):, :, :] else: raise NotImplementedError base_sigma += xp_functions._softplus_inverse(1.0) return distributions.Independent(D.Normal( loc=loc, scale=F.softplus( functions.clamp(base_sigma, xp_functions._softplus_inverse(0.001)))), reinterpreted_batch_ndims=ndim)
def setUp_configure(self): from scipy import stats self.dist = lambda **params: distributions.Independent( distributions.Normal(**params), self.reinterpreted_batch_ndims) self.test_targets = set( ["batch_shape", "entropy", "event_shape", "log_prob", "support"]) loc = utils.force_array( numpy.random.uniform(-1, 1, self.full_shape).astype(numpy.float32)) scale = utils.force_array( numpy.exp(numpy.random.uniform(-1, 1, self.full_shape)).astype( numpy.float32)) if self.reinterpreted_batch_ndims is None: reinterpreted_batch_ndims = max(0, len(self.inner_shape) - 1) else: reinterpreted_batch_ndims = self.reinterpreted_batch_ndims batch_ndim = len(self.inner_shape) - reinterpreted_batch_ndims self.shape = self.inner_shape[:batch_ndim] self.event_shape = \ self.inner_shape[batch_ndim:] + self.inner_event_shape d = functools.reduce(operator.mul, self.event_shape, 1) if self.event_shape == (): self.scipy_dist = stats.norm self.params = {"loc": loc, "scale": scale} self.scipy_params = {"loc": loc, "scale": scale} else: self.scipy_dist = stats.multivariate_normal scale_tril = numpy.eye(d).astype(numpy.float32) * \ scale.reshape(self.shape + (d,))[..., None] cov = numpy.einsum('...ij,...jk->...ik', scale_tril, scale_tril) self.params = {"loc": loc, "scale": scale} self.scipy_params = { "mean": numpy.reshape(loc, self.shape + (d, )), "cov": cov }
def __call__(self, x): h = F.relu(self.c1(x)) h = F.average_pooling_2d(h, 2, 2, 0) h = F.relu(self.c2(h)) h = F.average_pooling_2d(h, 2, 2, 0) h = F.relu(self.c3(h)) h = F.average_pooling_2d(h, 2, 2, 0) h = F.relu(self.c4(h)) h = F.average_pooling_2d(h, 2, 2, 0) h = F.relu(self.c5(h)) h = F.average_pooling_2d(h, 2, 2, 0) h = F.relu(self.c6(h)) h = self.c7(h) return D.Normal(loc=h[:, :256], log_scale=h[:, 256:])
def __call__(self, x): h = F.relu(self.bn_c1(self.c1(x))) h = F.average_pooling_2d(h, 2, 2, 0) h = F.relu(self.res2(h)) h = F.average_pooling_2d(h, 2, 2, 0) h = F.relu(self.res3(h)) h = F.average_pooling_2d(h, 2, 2, 0) h = F.relu(self.res4(h)) h = F.average_pooling_2d(h, 2, 2, 0) h = F.relu(self.res5(h)) # h = F.average_pooling_2d(h, 2, 2, 0) # h = F.relu(self.res6(h)) # h = self.c7(h) h = self.bn_l6(self.l6(h)) # s = self.bn_std(self.l_std(h)) return D.Normal(loc=h[:, :self.n_ch * 4], log_scale=h[:, self.n_ch * 4:])
def to_dist_fn(h): return distributions.Independent( D.Normal(loc=h[..., :n_latent], scale=F.softplus(h[..., n_latent:])))
def to_dist_fn(h): mu, ln_sigma = h return distributions.Independent(D.Normal( loc=mu, scale=F.softplus(ln_sigma)))
def __call__(self): return D.Normal(self.loc, scale=self.scale)
def to_dist_fn(h): loc, scale = h return distributions.Independent(D.Normal(loc, scale), reinterpreted_batch_ndims=1)
def normal_prob(self, y, mu, log_var): squared_sigma = F.exp(log_var) sigma = F.sqrt(squared_sigma) d = distributions.Normal(mu, scale=sigma) return F.clip(d.prob(y), 0., 1.)
def __call__(self, x): h = F.tanh(self.fc1(x)) ave = self.fc2_ave(h) var = self.fc2_var(h) # log(sigma) return D.Normal(loc=ave, log_scale=var)
def test_batch_ndim_error(self): with self.assertRaises(ValueError): distributions.Independent(distributions.Normal(**self.params), len(self.inner_shape) + 1)
def forward(self): return D.Normal(self.loc, scale=self.scale)
def forward(self, x): h = F.tanh(self.linear(x)) mu = self.mu(h) ln_sigma = self.ln_sigma(h) # log(sigma) return D.Independent(D.Normal(loc=mu, log_scale=ln_sigma))
def forward(self): return D.Independent(D.Normal(self.loc, scale=self.scale), reinterpreted_batch_ndims=1)