def logpdf(self, rowid, targets, constraints=None, inputs=None):
DistributionGpm.logpdf(self, rowid, targets, constraints, inputs)
x = targets[self.outputs[0]]
if not (x % 1 == 0 and x >= 0):
return -float('inf')
return Poisson.calc_predictive_logp(x, self.N, self.sum_x, self.a,
self.b)
def __init__(self,
outputs,
inputs,
hypers=None,
params=None,
distargs=None,
rng=None):
DistributionGpm.__init__(self, outputs, inputs, hypers, params,
distargs, rng)
# Distargs
self.l = distargs['l']
self.h = distargs['h']
# Sufficient statistics.
self.N = 0
self.sum_x = 0
self.sum_x_sq = 0
# Hyperparameters (fixed).
self.alpha = 2.
self.beta = 2.
# Uncollapsed mean and precision parameters.
if params is None: params = {}
self.mu = params.get('mu', None)
self.sigma = params.get('sigma', 1)
if not self.mu or not self.sigma:
self.mu, self.sigma = NormalTrunc.sample_parameters(
self.alpha, self.beta, self.l, self.h, self.rng)
def logpdf(self, rowid, targets, constraints=None, inputs=None):
DistributionGpm.logpdf(self, rowid, targets, constraints, inputs)
x = targets[self.outputs[0]]
if x not in [0, 1]:
return -float('inf')
return Bernoulli.calc_predictive_logp(x, self.N, self.x_sum,
self.alpha, self.beta)
def incorporate(self, rowid, observation, inputs=None):
DistributionGpm.incorporate(self, rowid, observation, inputs)
x = observation[self.outputs[0]]
self.N += 1.
self.sum_x += x
self.sum_x_sq += x * x
self.data[rowid] = x
def logpdf(self, rowid, targets, constraints=None, inputs=None):
DistributionGpm.logpdf(self, rowid, targets, constraints, inputs)
x = targets[self.outputs[0]]
if x < 0:
return -float('inf')
return Exponential.calc_predictive_logp(x, self.N, self.sum_x, self.a,
self.b)
def simulate(self, rowid, targets, constraints=None, inputs=None, N=None):
DistributionGpm.simulate(self, rowid, targets, constraints, inputs, N)
if rowid in self.data:
return {self.outputs[0]: self.data[rowid]}
an, bn = Poisson.posterior_hypers(self.N, self.sum_x, self.a, self.b)
x = self.rng.negative_binomial(an, bn / (bn + 1.))
return {self.outputs[0]: x}
def logpdf(self, rowid, targets, constraints=None, inputs=None):
DistributionGpm.logpdf(self, rowid, targets, constraints, inputs)
x = targets[self.outputs[0]]
if not (x % 1 == 0 and 0 <= x < self.k):
return -float('inf')
return Categorical.calc_predictive_logp(int(x), self.N, self.counts,
self.alpha)
def incorporate(self, rowid, observation, inputs=None):
DistributionGpm.incorporate(self, rowid, observation, inputs)
x = observation[self.outputs[0]]
if x not in [0, 1]:
raise ValueError('Invalid Bernoulli: %s' % str(x))
self.N += 1
self.x_sum += x
self.data[rowid] = x
def simulate(self, rowid, targets, constraints=None, inputs=None, N=None):
DistributionGpm.simulate(self, rowid, targets, constraints, inputs, N)
if rowid in self.data:
return {self.outputs[0]: self.data[rowid]}
alpha = self.strength * self.balance
beta = self.strength * (1. - self.balance)
x = self.rng.beta(alpha, beta)
return {self.outputs[0]: x}
def incorporate(self, rowid, observation, inputs=None):
DistributionGpm.incorporate(self, rowid, observation, inputs)
x = observation[self.outputs[0]]
if x < 0:
raise ValueError('Invalid Exponential: %s' % str(x))
self.N += 1
self.sum_x += x
self.data[rowid] = x
def simulate(self, rowid, targets, constraints=None, inputs=None, N=None):
DistributionGpm.simulate(self, rowid, targets, constraints, inputs, N)
if rowid in self.data:
return {self.outputs[0]: self.data[rowid]}
an, bn = Geometric.posterior_hypers(self.N, self.sum_x, self.a, self.b)
pn = self.rng.beta(an, bn)
x = self.rng.geometric(pn) - 1
return {self.outputs[0]: x}
def incorporate(self, rowid, observation, inputs=None):
DistributionGpm.incorporate(self, rowid, observation, inputs)
x = observation[self.outputs[0]]
if not (x % 1 == 0 and x >= 0):
raise ValueError('Invalid Geometric: %s') % str(x)
self.N += 1
self.sum_x += x
self.data[rowid] = x
def incorporate(self, rowid, observation, inputs=None):
DistributionGpm.incorporate(self, rowid, observation, inputs)
x = int(observation[self.outputs[0]])
self.N += 1
if x not in self.counts:
self.counts[x] = 0
self.counts[x] += 1
self.data[rowid] = x
def logpdf(self, rowid, targets, constraints=None, inputs=None):
DistributionGpm.logpdf(self, rowid, targets, constraints, inputs)
x = targets[self.outputs[0]]
if not (0 <= x <= 2 * pi):
return -float('inf')
return Vonmises.calc_predictive_logp(x, self.N, self.sum_sin_x,
self.sum_cos_x, self.a, self.b,
self.k)
def incorporate(self, rowid, observation, inputs=None):
DistributionGpm.incorporate(self, rowid, observation, inputs)
x = observation[self.outputs[0]]
if x <= 0:
raise ValueError('Invalid Lognormal: %s' % str(x))
self.N += 1
self.sum_log_x += log(x)
self.sum_log_x_sq += log(x) * log(x)
self.data[rowid] = x
def simulate(self, rowid, targets, constraints=None, inputs=None, N=None):
DistributionGpm.simulate(self, rowid, targets, constraints, inputs, N)
if rowid in self.data:
return {self.outputs[0]: self.data[rowid]}
an, bn = Exponential.posterior_hypers(self.N, self.sum_x, self.a,
self.b)
mu = self.rng.gamma(an, scale=1. / bn)
x = self.rng.exponential(scale=1. / mu)
return {self.outputs[0]: x}
def incorporate(self, rowid, observation, inputs=None):
DistributionGpm.incorporate(self, rowid, observation, inputs)
x = observation[self.outputs[0]]
if not (x % 1 == 0 and x >= 0):
raise ValueError('Invalid Poisson: %s' % str(x))
self.N += 1
self.sum_x += x
self.sum_log_fact_x += gammaln(x + 1)
self.data[rowid] = x
def incorporate(self, rowid, observation, inputs=None):
DistributionGpm.incorporate(self, rowid, observation, inputs)
x = observation[self.outputs[0]]
if not (x % 1 == 0 and 0 <= x < self.k):
raise ValueError('Invalid Categorical(%d): %s' % (self.k, x))
x = int(x)
self.N += 1
self.counts[x] += 1
self.data[rowid] = x
def logpdf(self, rowid, targets, constraints=None, inputs=None):
DistributionGpm.logpdf(self, rowid, targets, constraints, inputs)
x = targets[self.outputs[0]]
if x <= 0:
return -float('inf')
return - log(x) + \
Normal.calc_predictive_logp(
log(x), self.N, self.sum_log_x, self.sum_log_x_sq, self.m,
self.r, self.s, self.nu)
def incorporate(self, rowid, observation, inputs=None):
DistributionGpm.incorporate(self, rowid, observation, inputs)
x = observation[self.outputs[0]]
if not (0 <= x <= 2 * pi):
raise ValueError('Invalid Vonmises: %s' % str(x))
self.N += 1
self.sum_sin_x += sin(x)
self.sum_cos_x += cos(x)
self.data[rowid] = x
def logpdf(self, rowid, targets, constraints=None, inputs=None):
DistributionGpm.logpdf(self, rowid, targets, constraints, inputs)
x = targets[self.outputs[0]]
if not (self.l <= x <= self.h):
return -float('inf')
logpdf_unorm = NormalTrunc.calc_predictive_logp(
x, self.mu, self.sigma, self.l, self.h)
logcdf_norm = NormalTrunc.calc_log_normalizer(self.mu, self.sigma,
self.l, self.h)
return logpdf_unorm - logcdf_norm
def simulate(self, rowid, targets, constraints=None, inputs=None, N=None):
DistributionGpm.simulate(self, rowid, targets, constraints, inputs, N)
if rowid in self.data:
x = self.data[rowid]
else:
K = sorted(self.counts) + [max(self.counts) + 1] if self.counts\
else [0]
logps = [self.logpdf(rowid, {targets[0]: x}, None) for x in K]
x = gu.log_pflip(logps, array=K, rng=self.rng)
return {self.outputs[0]: x}
def incorporate(self, rowid, observation, inputs=None):
DistributionGpm.incorporate(self, rowid, observation, inputs)
x = observation[self.outputs[0]]
if not (self.l <= x <= self.h):
raise ValueError('Invalid NormalTrunc(%f,%f): %s' %
(self.l, self.h, str(x)))
self.N += 1
self.sum_x += x
self.sum_x_sq += x * x
self.data[rowid] = x
def simulate(self, rowid, targets, constraints=None, inputs=None, N=None):
DistributionGpm.simulate(self, rowid, targets, constraints, inputs, N)
if rowid in self.data:
return {self.outputs[0]: self.data[rowid]}
mn, rn, sn, nun = Normal.posterior_hypers(self.N, self.sum_x,
self.sum_x_sq, self.m,
self.r, self.s, self.nu)
mu, rho = Normal.sample_parameters(mn, rn, sn, nun, self.rng)
x = self.rng.normal(loc=mu, scale=rho**-.5)
return {self.outputs[0]: x}
def simulate(self, rowid, targets, constraints=None, inputs=None, N=None):
DistributionGpm.simulate(self, rowid, targets, constraints, inputs, N)
if rowid in self.data:
return {self.outputs[0]: self.data[rowid]}
p0 = Bernoulli.calc_predictive_logp(0, self.N, self.x_sum, self.alpha,
self.beta)
p1 = Bernoulli.calc_predictive_logp(1, self.N, self.x_sum, self.alpha,
self.beta)
x = gu.log_pflip([p0, p1], rng=self.rng)
return {self.outputs[0]: x}
def simulate(self, rowid, targets, constraints=None, inputs=None, N=None):
DistributionGpm.simulate(self, rowid, targets, constraints, inputs, N)
if rowid in self.data:
return {self.outputs[0]: self.data[rowid]}
max_iters = 1000
for i in xrange(max_iters):
x = self.rng.normal(loc=self.mu, scale=self.sigma)
if self.l <= x <= self.h:
return {self.outputs[0]: x}
else:
raise RuntimeError('NormalTrunc failed to rejection sample.')
def __init__(
self, outputs, inputs,
hypers=None, params=None, distargs=None, rng=None):
DistributionGpm.__init__(
self, outputs, inputs, hypers, params, distargs, rng)
# Distargs.
self.N = 0
self.data = OrderedDict()
self.counts = OrderedDict()
# Hyperparameters.
if hypers is None: hypers = {}
self.alpha = hypers.get('alpha', 1.)
def simulate(self, rowid, targets, constraints=None, inputs=None, N=None):
DistributionGpm.simulate(self, rowid, targets, constraints, inputs, N)
if rowid in self.data:
return {self.outputs[0]: self.data[rowid]}
an, bn = Vonmises.posterior_hypers(self.N, self.sum_sin_x,
self.sum_cos_x, self.a, self.b,
self.k)
# if not 0 <= bn <= 2*pi:
# import ipdb; ipdb.set_trace()
mu = self.rng.vonmises(bn - pi, an) + pi
x = self.rng.vonmises(mu - pi, self.k) + pi
assert 0 <= x <= 2 * pi
return {self.outputs[0]: x}
def incorporate(self, rowid, observation, inputs=None):
DistributionGpm.incorporate(self, rowid, observation, inputs)
x = observation[self.outputs[0]]
if np.allclose(0, x):
x = 0.001
elif np.allclose(1, x):
x = 0.999
if not 0 < x < 1:
raise ValueError('Invalid Beta: %s' % str(x))
self.N += 1
self.sum_log_x += log(x)
self.sum_minus_log_x += log(1.-x)
self.data[rowid] = x
def simulate(self, rowid, targets, constraints=None, inputs=None, N=None):
# XXX This implementation is not verified but will be covered in
# future univariate simulate tests, see Github issue #14.
DistributionGpm.simulate(self, rowid, targets, constraints, inputs, N)
if rowid in self.data:
return {self.outputs[0]: self.data[rowid]}
# Simulate normal parameters.
mn, rn, sn, nun = Normal.posterior_hypers(self.N, self.sum_log_x,
self.sum_log_x_sq, self.m,
self.r, self.s, self.nu)
mu, rho = Normal.sample_parameters(mn, rn, sn, nun, self.rng)
xn = self.rng.normal(loc=mu, scale=rho**-.5)
x = np.exp(xn)
return {self.outputs[0]: x}
