本文整理匯總了Python中torch.distributions.Normal方法的典型用法代碼示例。如果您正苦於以下問題:Python distributions.Normal方法的具體用法?Python distributions.Normal怎麽用?Python distributions.Normal使用的例子?那麽, 這裏精選的方法代碼示例或許可以為您提供幫助。您也可以進一步了解該方法所在類torch.distributions
的用法示例。
在下文中一共展示了distributions.Normal方法的15個代碼示例,這些例子默認根據受歡迎程度排序。您可以為喜歡或者感覺有用的代碼點讚,您的評價將有助於係統推薦出更棒的Python代碼示例。
示例1: __init__
# 需要導入模塊: from torch import distributions [as 別名]
# 或者: from torch.distributions import Normal [as 別名]
def __init__(self, hidden, a=1., scale=1.):
"""
Implements a State Space model that's linear in the observation equation but has arbitrary dynamics in the
state process.
:param hidden: The hidden dynamics
:param a: The A-matrix
:param scale: The variance of the observations
"""
# ===== Convoluted way to decide number of dimensions ===== #
dim, is_1d = _get_shape(a)
# ====== Define distributions ===== #
n = dists.Normal(0., 1.) if is_1d else dists.Independent(dists.Normal(torch.zeros(dim), torch.ones(dim)), 1)
if not isinstance(scale, (torch.Tensor, float, dists.Distribution)):
raise ValueError(f'`scale` parameter must be numeric type!')
super().__init__(hidden, a, scale, n)
示例2: __init__
# 需要導入模塊: from torch import distributions [as 別名]
# 或者: from torch.distributions import Normal [as 別名]
def __init__(self, theta, initial_dist, dt, num_steps=10):
"""
Similar as `OneFactorFractionalStochasticSIR`, but we now have two sources of randomness originating from shocks
to both paramters `beta` and `gamma`.
:param theta: The parameters (beta, gamma, sigma, eta)
"""
if initial_dist.event_shape != torch.Size([3]):
raise NotImplementedError('Must be of size 3!')
def g(x, gamma, beta, sigma, eps):
s = torch.zeros((*x.shape[:-1], 3, 2), device=x.device)
s[..., 0, 0] = -sigma * x[..., 0] * x[..., 1]
s[..., 1, 0] = -s[..., 0, 0]
s[..., 1, 1] = -eps * x[..., 1]
s[..., 2, 1] = -s[..., 1, 1]
return s
f_ = lambda u, beta, gamma, sigma, eps: f(u, beta, gamma, sigma)
inc_dist = Independent(Normal(torch.zeros(2), math.sqrt(dt) * torch.ones(2)), 1)
super().__init__((f_, g), theta, initial_dist, inc_dist, dt=dt, num_steps=num_steps)
示例3: __init__
# 需要導入模塊: from torch import distributions [as 別名]
# 或者: from torch.distributions import Normal [as 別名]
def __init__(self, kappa, gamma, sigma, ndim: int, dt: float):
"""
Implements the Ornstein-Uhlenbeck process.
:param kappa: The reversion parameter
:param gamma: The mean parameter
:param sigma: The standard deviation
:param ndim: The number of dimensions for the Brownian motion
"""
def f(x: torch.Tensor, reversion: object, level: object, std: object):
return level + (x - level) * torch.exp(-reversion * dt)
def g(x: torch.Tensor, reversion: object, level: object, std: object):
return std / (2 * reversion).sqrt() * (1 - torch.exp(-2 * reversion * dt)).sqrt()
if ndim > 1:
dist = Independent(Normal(torch.zeros(ndim), torch.ones(ndim)), 1)
else:
dist = Normal(0., 1)
super().__init__((f, g), (kappa, gamma, sigma), dist, dist)
示例4: test_SDE
# 需要導入模塊: from torch import distributions [as 別名]
# 或者: from torch.distributions import Normal [as 別名]
def test_SDE(self):
def f(x, a, s):
return -a * x
def g(x, a, s):
return s
em = AffineEulerMaruyama((f, g), (0.02, 0.15), Normal(0., 1.), Normal(0., 1.), dt=1e-2, num_steps=10)
model = LinearGaussianObservations(em, scale=1e-3)
x, y = model.sample_path(500)
for filt in [SISR(model, 500, proposal=Bootstrap()), UKF(model)]:
filt = filt.initialize().longfilter(y)
means = filt.result.filter_means
if isinstance(filt, UKF):
means = means[:, 0]
self.assertLess(torch.std(x - means), 5e-2)
示例5: test_StateDict
# 需要導入模塊: from torch import distributions [as 別名]
# 或者: from torch.distributions import Normal [as 別名]
def test_StateDict(self):
# ===== Define model ===== #
norm = Normal(0., 1.)
linear = AffineProcess((f, g), (1., 1.), norm, norm)
linearobs = AffineObservations((fo, go), (1., 1.), norm)
model = StateSpaceModel(linear, linearobs)
# ===== Define filter ===== #
filt = SISR(model, 100).initialize()
# ===== Get statedict ===== #
sd = filt.state_dict()
# ===== Verify that we don't save multiple instances ===== #
assert '_model' in sd and '_model' not in sd['_proposal']
newfilt = SISR(model, 1000).load_state_dict(sd)
assert newfilt._w_old is not None and newfilt.ssm is newfilt._proposal._model
# ===== Test same with UKF and verify that we save UT ===== #
ukf = UKF(model).initialize()
sd = ukf.state_dict()
assert '_model' in sd and '_model' not in sd['_ut']
示例6: test_Stacker
# 需要導入模塊: from torch import distributions [as 別名]
# 或者: from torch.distributions import Normal [as 別名]
def test_Stacker(self):
# ===== Define a mix of parameters ====== #
zerod = Parameter(Normal(0., 1.)).sample_((1000,))
oned_luring = Parameter(Normal(torch.tensor([0.]), torch.tensor([1.]))).sample_(zerod.shape)
oned = Parameter(MultivariateNormal(torch.zeros(2), torch.eye(2))).sample_(zerod.shape)
mu = torch.zeros((3, 3))
norm = Independent(Normal(mu, torch.ones_like(mu)), 2)
twod = Parameter(norm).sample_(zerod.shape)
# ===== Stack ===== #
params = (zerod, oned, oned_luring, twod)
stacked = stacker(params, lambda u: u.t_values, dim=1)
# ===== Verify it's recreated correctly ====== #
for p, m, ps in zip(params, stacked.mask, stacked.prev_shape):
v = stacked.concated[..., m]
if len(p.c_shape) != 0:
v = v.reshape(*v.shape[:-1], *ps)
assert (p.t_values == v).all()
示例7: test_Sample
# 需要導入模塊: from torch import distributions [as 別名]
# 或者: from torch.distributions import Normal [as 別名]
def test_Sample(self):
# ==== Hidden ==== #
norm = Normal(0., 1.)
linear = AffineProcess((f, g), (1., 1.), norm, norm)
# ==== Observable ===== #
obs = AffineObservations((fo, go), (1., 0.), norm)
# ===== Model ===== #
mod = StateSpaceModel(linear, obs)
# ===== Sample ===== #
x, y = mod.sample_path(100)
diff = ((x - y) ** 2).mean().sqrt()
assert x.shape == y.shape and x.shape[0] == 100 and diff < 1e-3
示例8: test_LinearBatch
# 需要導入模塊: from torch import distributions [as 別名]
# 或者: from torch.distributions import Normal [as 別名]
def test_LinearBatch(self):
norm = Normal(0., 1.)
linear = AffineProcess((f, g), (1., 1.), norm, norm)
# ===== Initialize ===== #
shape = 1000, 100
x = linear.i_sample(shape)
# ===== Propagate ===== #
num = 100
samps = [x]
for t in range(num):
samps.append(linear.propagate(samps[-1]))
samps = torch.stack(samps)
self.assertEqual(samps.size(), torch.Size([num + 1, *shape]))
# ===== Sample path ===== #
path = linear.sample_path(num + 1, shape)
self.assertEqual(samps.shape, path.shape)
示例9: test_BatchedParameter
# 需要導入模塊: from torch import distributions [as 別名]
# 或者: from torch.distributions import Normal [as 別名]
def test_BatchedParameter(self):
norm = Normal(0., 1.)
shape = 1000, 100
a = torch.ones((shape[0], 1))
init = Normal(a, 1.)
linear = AffineProcess((f, g), (a, 1.), init, norm)
# ===== Initialize ===== #
x = linear.i_sample(shape)
# ===== Propagate ===== #
num = 100
samps = [x]
for t in range(num):
samps.append(linear.propagate(samps[-1]))
samps = torch.stack(samps)
self.assertEqual(samps.size(), torch.Size([num + 1, *shape]))
# ===== Sample path ===== #
path = linear.sample_path(num + 1, shape)
self.assertEqual(samps.shape, path.shape)
示例10: test_MultiDimensional
# 需要導入模塊: from torch import distributions [as 別名]
# 或者: from torch.distributions import Normal [as 別名]
def test_MultiDimensional(self):
mu = torch.zeros(2)
scale = torch.ones_like(mu)
shape = 1000, 100
mvn = Independent(Normal(mu, scale), 1)
mvn = AffineProcess((f, g), (1., 1.), mvn, mvn)
# ===== Initialize ===== #
x = mvn.i_sample(shape)
# ===== Propagate ===== #
num = 100
samps = [x]
for t in range(num):
samps.append(mvn.propagate(samps[-1]))
samps = torch.stack(samps)
self.assertEqual(samps.size(), torch.Size([num + 1, *shape, *mu.shape]))
# ===== Sample path ===== #
path = mvn.sample_path(num + 1, shape)
self.assertEqual(samps.shape, path.shape)
示例11: test_SDE
# 需要導入模塊: from torch import distributions [as 別名]
# 或者: from torch.distributions import Normal [as 別名]
def test_SDE(self):
shape = 1000, 100
a = 1e-2 * torch.ones((shape[0], 1))
dt = 0.1
norm = Normal(0., math.sqrt(dt))
init = Normal(a, 1.)
sde = AffineEulerMaruyama((f_sde, g_sde), (a, 0.15), init, norm, dt=dt, num_steps=10)
# ===== Initialize ===== #
x = sde.i_sample(shape)
# ===== Propagate ===== #
num = 100
samps = [x]
for t in range(num):
samps.append(sde.propagate(samps[-1]))
samps = torch.stack(samps)
self.assertEqual(samps.size(), torch.Size([num + 1, *shape]))
# ===== Sample path ===== #
path = sde.sample_path(num + 1, shape)
self.assertEqual(samps.shape, path.shape)
示例12: rsample_with_pre_tanh_value
# 需要導入模塊: from torch import distributions [as 別名]
# 或者: from torch.distributions import Normal [as 別名]
def rsample_with_pre_tanh_value(self, sample_shape=torch.Size()):
"""Return a sample, sampled from this TanhNormal distribution.
Returns the sampled value before the tanh transform is applied and the
sampled value with the tanh transform applied to it.
Args:
sample_shape (list): shape of the return.
Note:
Gradients pass through this operation.
Returns:
torch.Tensor: Samples from this distribution.
torch.Tensor: Samples from the underlying
:obj:`torch.distributions.Normal` distribution, prior to being
transformed with `tanh`.
"""
z = self._normal.rsample(sample_shape)
return z, torch.tanh(z)
示例13: _from_distribution
# 需要導入模塊: from torch import distributions [as 別名]
# 或者: from torch.distributions import Normal [as 別名]
def _from_distribution(cls, new_normal):
"""Construct a new TanhNormal distribution from a normal distribution.
Args:
new_normal (Independent(Normal)): underlying normal dist for
the new TanhNormal distribution.
Returns:
TanhNormal: A new distribution whose underlying normal dist
is new_normal.
"""
# pylint: disable=protected-access
new = cls(torch.zeros(1), torch.zeros(1))
new._normal = new_normal
return new
示例14: normal_parse_params
# 需要導入模塊: from torch import distributions [as 別名]
# 或者: from torch.distributions import Normal [as 別名]
def normal_parse_params(params, min_sigma=0):
"""
Take a Tensor (e. g. neural network output) and return
torch.distributions.Normal distribution.
This Normal distribution is component-wise independent,
and its dimensionality depends on the input shape.
First half of channels is mean of the distribution,
the softplus of the second half is std (sigma), so there is
no restrictions on the input tensor.
min_sigma is the minimal value of sigma. I. e. if the above
softplus is less than min_sigma, then sigma is clipped
from below with value min_sigma. This regularization
is required for the numerical stability and may be considered
as a neural network architecture choice without any change
to the probabilistic model.
"""
n = params.shape[0]
d = params.shape[1]
mu = params[:, :d // 2]
sigma_params = params[:, d // 2:]
sigma = softplus(sigma_params)
sigma = sigma.clamp(min=min_sigma)
distr = Normal(mu, sigma)
return distr
示例15: __init__
# 需要導入模塊: from torch import distributions [as 別名]
# 或者: from torch.distributions import Normal [as 別名]
def __init__(self, num_key, num_cate):
super(Loss, self).__init__(True)
self.num_key = num_key
self.num_cate = num_cate
self.oneone = Variable(torch.ones(1)).cuda()
self.normal = tdist.Normal(torch.tensor([0.0]), torch.tensor([0.0005]))
self.pconf = torch.ones(num_key) / num_key
self.pconf = Variable(self.pconf).cuda()
self.sym_axis = Variable(torch.from_numpy(np.array([0, 1, 0]).astype(np.float32))).cuda().view(1, 3, 1)
self.threezero = Variable(torch.from_numpy(np.array([0, 0, 0]).astype(np.float32))).cuda()
self.zeros = torch.FloatTensor([0.0 for j in range(num_key-1) for i in range(num_key)]).cuda()
self.select1 = torch.tensor([i for j in range(num_key-1) for i in range(num_key)]).cuda()
self.select2 = torch.tensor([(i%num_key) for j in range(1, num_key) for i in range(j, j+num_key)]).cuda()
self.knn = KNearestNeighbor(1)