def to_common_arr(x):
""" Numerically stable transform from real line to positive reals
Returns ag_np.log(1.0 + ag_np.exp(x))
Autograd friendly and fully vectorized
Args
----
x : array of values in (-\infty, +\infty)
Returns
-------
ans : array of values in (0, +\infty), same size as x
"""
if not isinstance(x, float):
mask1 = x > 0
mask0 = ag_np.logical_not(mask1)
out = ag_np.zeros_like(x)
out[mask0] = ag_np.log1p(ag_np.exp(x[mask0]))
out[mask1] = x[mask1] + ag_np.log1p(ag_np.exp(-x[mask1]))
return out
if x > 0:
return x + ag_np.log1p(ag_np.exp(-x))
else:
return ag_np.log1p(ag_np.exp(x))
def to_unconstrained_arr(p):
""" Numerically stable transform from positive reals to real line
Implements ag_np.log(ag_np.exp(x) - 1.0)
Autograd friendly and fully vectorized
Args
----
p : array of values in (0, +\infty)
Returns
-------
ans : array of values in (-\infty, +\infty), same size as p
"""
## Handle numpy array case
if not isinstance(p, float):
mask1 = p > 10.0
mask0 = ag_np.logical_not(mask1)
out = ag_np.zeros_like(p)
out[mask0] = ag_np.log(ag_np.expm1(p[mask0]))
out[mask1] = p[mask1] + ag_np.log1p(-ag_np.exp(-p[mask1]))
return out
## Handle scalar float case
else:
if p > 10:
return p + ag_np.log1p(-ag_np.exp(-p))
else:
return ag_np.log(ag_np.expm1(p))
def stick_jacobian_det(y_):
y = y_.T
Km1 = y.shape[0]
k = np.arange(Km1)[(slice(None), ) + (None, ) * (y.ndim - 1)]
eq_share = logit(1. / (Km1 + 1 - k)) # -np.log(Km1 - k)
yl = y + eq_share
yu = np.concatenate([np.ones(y[:1].shape), 1 - invlogit(yl)])
S = cumprod(yu)
return np.sum(
np.log(S[:-1]) - np.log1p(np.exp(yl)) - np.log1p(np.exp(-yl)), 0).T
def predict_cumulative_hazard(self, X, times=None, ancillary_X=None):
"""
Return the cumulative hazard rate of subjects in X at time points.
Parameters
----------
X: numpy array or DataFrame
a (n,d) covariate numpy array or DataFrame. If a DataFrame, columns
can be in any order. If a numpy array, columns must be in the
same order as the training data.
times: iterable, optional
an iterable of increasing times to predict the cumulative hazard at. Default
is the set of all durations (observed and unobserved). Uses a linear interpolation if
points in time are not in the index.
ancillary_X: numpy array or DataFrame, optional
a (n,d) covariate numpy array or DataFrame. If a DataFrame, columns
can be in any order. If a numpy array, columns must be in the
same order as the training data.
Returns
-------
cumulative_hazard_ : DataFrame
the cumulative hazard of individuals over the timeline
"""
times = coalesce(times, self.timeline, np.unique(self.durations))
alpha_, beta_ = self._prep_inputs_for_prediction_and_return_scores(X, ancillary_X)
return pd.DataFrame(np.log1p(np.outer(times, 1 / alpha_) ** beta_), columns=_get_index(X), index=times)
def predict_cumulative_hazard(self, X, times=None, ancillary_X=None):
"""
Return the cumulative hazard rate of subjects in X at time points.
Parameters
----------
X: numpy array or DataFrame
a (n,d) covariate numpy array or DataFrame. If a DataFrame, columns
can be in any order. If a numpy array, columns must be in the
same order as the training data.
times: iterable, optional
an iterable of increasing times to predict the cumulative hazard at. Default
is the set of all durations (observed and unobserved). Uses a linear interpolation if
points in time are not in the index.
ancillary_X: numpy array or DataFrame, optional
a (n,d) covariate numpy array or DataFrame. If a DataFrame, columns
can be in any order. If a numpy array, columns must be in the
same order as the training data.
Returns
-------
cumulative_hazard_ : DataFrame
the cumulative hazard of individuals over the timeline
"""
times = coalesce(times, self.timeline, np.unique(self.durations))
alpha_, beta_ = self._prep_inputs_for_prediction_and_return_scores(X, ancillary_X)
return pd.DataFrame(np.log1p(np.outer(times, 1 / alpha_) ** beta_), columns=_get_index(X), index=times)
def inv_logistic_sigmoid(
p, do_force_safe=True):
''' Compute inverse logistic sigmoid from unit interval to reals.
Numerically stable and fully vectorized.
Args
----
p : array-like, with values in (0, 1)
Returns
-------
x : array-like, size of p, with values in (-infty, infty)
Examples
--------
>>> np.round(inv_logistic_sigmoid(0.11), 6)
-2.090741
>>> np.round(inv_logistic_sigmoid(0.5), 6)
0.0
>>> np.round(inv_logistic_sigmoid(0.89), 6)
2.090741
>>> p_vec = np.asarray([
... 1e-100, 1e-10, 1e-5,
... 0.25, 0.75, .9999, 1-1e-14])
>>> np.round(inv_logistic_sigmoid(p_vec), 2)
array([-230.26, -23.03, -11.51, -1.1 , 1.1 , 9.21, 32.24])
'''
if do_force_safe:
p = np.minimum(np.maximum(p, MIN_VAL), MAX_VAL)
return np.log(p) - np.log1p(-p)
def _cumulative_hazard(self, params, T, *Xs):
alpha_params = params[self._LOOKUP_SLICE["alpha_"]]
alpha_ = np.exp(np.dot(Xs[0], alpha_params))
beta_params = params[self._LOOKUP_SLICE["beta_"]]
beta_ = np.exp(np.dot(Xs[1], beta_params))
return np.log1p((T / alpha_) ** beta_)
def test_e_logistic_term(self):
z_dim = (3, 2)
z_mean = np.random.random(z_dim)
z_sd = np.exp(z_mean)
num_std_draws = 100
std_draws = model.get_standard_draws(num_std_draws)
# This would normally be a matrix of zeros and ones
y = np.random.random(z_dim)
num_draws = 10000
z_draws = sp.stats.norm(loc=z_mean, scale=z_sd).rvs(
(num_draws, z_dim[0], z_dim[1]))
logit_term_draws = \
np.expand_dims(y, axis=0) * z_draws - \
np.log1p(np.exp(z_draws))
# The Monte Carlo error will be dominated by the number of draws used
# in the get_e_logistic_term approximation.
test_se = np.max(
3 * np.std(logit_term_draws, axis=0) / np.sqrt(num_std_draws))
print('Logistic test moment tolerance: ', test_se)
np_test.assert_allclose(
np.sum(np.mean(logit_term_draws, axis=0)),
model.get_e_logistic_term(y, z_mean, z_sd, std_draws),
atol=test_se)
def to_diffable_arr(topics_KV, min_eps=MIN_EPS, do_force_safe=False):
''' Transform normalized topics to unconstrained space.
Args
----
topics_KV : 2D array, size K x V
minimum value of any entry must be min_eps
each row should sum to 1.0
Returns
-------
log_topics_vec : 2D array, size K x (V-1)
unconstrained real values
Examples
--------
>>> topics_KV = np.eye(3) + np.ones((3,3))
>>> topics_KV /= topics_KV.sum(axis=1)[:,np.newaxis]
>>> log_topics_vec = to_diffable_arr(topics_KV)
>>> out_KV = to_common_arr(log_topics_vec)
>>> np.allclose(out_KV, topics_KV)
True
'''
if do_force_safe:
topics_KV = to_safe_common_arr(topics_KV, min_eps)
K, V = topics_KV.shape
log_topics_KV = np.log(topics_KV)
log_topics_KVm1 = log_topics_KV[:, :-1]
log_topics_KVm1 = log_topics_KVm1 - log_topics_KV[:, -1][:, np.newaxis]
return log_topics_KVm1 + np.log1p(-V * min_eps)
def neg_hessian_log_emissions_prob(self, data, input, mask, tag, x):
"""
d/dx log p(y | x) = d/dx [y * (Cx + Fu + d) - exp(Cx + Fu + d)
= y * C - lmbda * C
= (y - lmbda) * C
d/dx (y - lmbda)^T C = d/dx -exp(Cx + Fu + d)^T C
= -C^T exp(Cx + Fu + d)^T C
"""
if self.link_name == "log":
assert self.single_subspace
lambdas = self.mean(self.forward(x, input, tag))
return -np.einsum('tn, ni, nj ->tij', -lambdas[:, 0, :],
self.Cs[0], self.Cs[0])
elif self.link_name == "softplus":
assert self.single_subspace
lambdas = np.log1p(
np.exp(
np.dot(x, self.Cs[0].T) + np.dot(input, self.Fs[0].T) +
self.ds[0]))
expterms = np.exp(-np.dot(x, self.Cs[0].T) -
np.dot(input, self.Fs[0].T) - self.ds[0])
diags = (data / lambdas * (expterms - 1.0 / lambdas) -
expterms) / (1.0 + expterms)**2
return -np.einsum('tn, ni, nj ->tij', diags, self.Cs[0],
self.Cs[0])
def _cumulative_hazard(self, params, T, *Xs):
alpha_params = params[self._LOOKUP_SLICE["alpha_"]]
alpha_ = np.exp(np.dot(Xs[0], alpha_params))
beta_params = params[self._LOOKUP_SLICE["beta_"]]
beta_ = np.exp(np.dot(Xs[1], beta_params))
return np.log1p((T / alpha_) ** beta_)
def log_logist(theta, Z, nu, mu, Sig):
dots = -np.dot(Z, theta.T)
log_lik = -np.sum(np.maximum(dots, 0) + np.log1p(np.exp(-np.abs(dots))),
axis=0)
log_pri = log_multivariate_t(theta[:, :-1], mu, Sig, nu) + log_cauchy(
theta[:, -1])
return log_pri + log_lik
def testConditionAndMarginalizeBernoulli(self):
def log_joint(x, logits):
return np.sum(x * logits)
p = np.random.beta(2., 2., [3, 4])
logit_p = np.log(p) - np.log1p(-p)
# TODO(mhoffman): Without the cast this gives wrong answers due to autograd
# casts. This is scary.
x = (np.random.uniform(size=(8,) + p.shape) < p).astype(np.float32)
conditional, marginalized_value = _condition_and_marginalize(
log_joint, 0, SupportTypes.BINARY, x, logit_p)
correct_marginalized_value = np.sum(-x.shape[0] * np.log1p(-p))
self.assertAlmostEqual(correct_marginalized_value, marginalized_value,
places=4)
self.assertTrue(np.allclose(p, conditional.args[0]))
def compute_derivs(self):
'''
lazy slow AD-based implementation ... should actually hand-compute
these for any serious use.
'''
Y = self.training_data.Y
z = self.training_data.X.dot(self.params.get_free())
f = lambda z, Y: -(Y * np.log(np.log1p(np.exp(z))) - np.log1p(np.exp(z)
))
grad = autograd.grad(f, argnum=0)
grad2 = autograd.grad(grad)
self.D1 = np.zeros(Y.shape[0])
self.D2 = np.zeros(Y.shape[0])
for n in range(Y.shape[0]):
self.D1[n] = grad(z[n], Y[n])
self.D2[n] = grad2(z[n], Y[n])
def decode(self, val, name):
assert val > self.lower, '{} = {} must be > self.lower = {}'.format(
name, val, self.lower)
# Inverse of encoding: Careful with numerics:
# val_int = log(exp(arg) - 1) = arg + log(1 - exp(-arg))
# = arg + log1p(-exp(-arg))
arg = val - self.lower
return arg + anp.log1p(-anp.exp(-arg))
def gpdfit(ary):
"""Estimate the parameters for the Generalized Pareto Distribution (GPD).
Empirical Bayes estimate for the parameters of the generalized Pareto
distribution given the data.
Parameters
----------
ary : array
sorted 1D data array
Returns
-------
k : float
estimated shape parameter
sigma : float
estimated scale parameter
"""
prior_bs = 3
prior_k = 10
n = len(ary)
m_est = 30 + int(n**0.5)
b_ary = 1 - np.sqrt(m_est / (np.arange(1, m_est + 1, dtype=float) - 0.5))
b_ary /= prior_bs * ary[int(n / 4 + 0.5) - 1]
b_ary += 1 / ary[-1]
k_ary = np.log1p(-b_ary[:, None] * ary).mean(axis=1) # pylint: disable=no-member
len_scale = n * (np.log(-(b_ary / k_ary)) - k_ary - 1)
weights = 1 / np.exp(len_scale - len_scale[:, None]).sum(axis=1)
# remove negligible weights
real_idxs = weights >= 10 * np.finfo(float).eps
if not np.all(real_idxs):
weights = weights[real_idxs]
b_ary = b_ary[real_idxs]
# normalise weights
weights /= weights.sum()
# posterior mean for b
b_post = np.sum(b_ary * weights)
# estimate for k
k_post = np.log1p(-b_post * ary).mean() # pylint: disable=invalid-unary-operand-type,no-member
# add prior for k_post
k_post = (n * k_post + prior_k * 0.5) / (n + prior_k)
sigma = -k_post / b_post
return k_post, sigma
def _cumulative_hazard(self, params, T, Xs):
Xbeta = np.dot(Xs["beta_"], params["beta_"])
lT = np.log(T)
return np.log1p(
np.exp(Xbeta +
(params["phi1_"] * lT + params["phi2_"] *
self.basis(lT, np.log(self.KNOTS[1]), np.log(
self.KNOTS[0]), np.log(self.KNOTS[-1])))))
def _log_1m_sf(self, params, T, *Xs):
alpha_params = params[self._LOOKUP_SLICE["alpha_"]]
log_alpha_ = np.dot(Xs[0], alpha_params)
alpha_ = np.exp(log_alpha_)
beta_params = params[self._LOOKUP_SLICE["beta_"]]
log_beta_ = np.dot(Xs[1], beta_params)
beta_ = np.exp(log_beta_)
return -np.log1p((T / alpha_)**-beta_)
def _log_1m_sf(self, params, T, *Xs):
alpha_params = params[self._LOOKUP_SLICE["alpha_"]]
log_alpha_ = np.dot(Xs[0], alpha_params)
alpha_ = np.exp(log_alpha_)
beta_params = params[self._LOOKUP_SLICE["beta_"]]
log_beta_ = np.dot(Xs[1], beta_params)
beta_ = np.exp(log_beta_)
return -np.log1p((T / alpha_) ** -beta_)
def softplus(x):
""" Numerically stable transform from real line to positive reals
Returns np.log(1.0 + np.exp(x))
Autograd friendly and fully vectorized
@param x: array of values in (-\infty, +\infty)
@return ans : array of values in (0, +\infty), same size as x
"""
if not isinstance(x, float):
mask1 = x > 0
mask0 = np.logical_not(mask1)
out = np.zeros_like(x)
out[mask0] = np.log1p(np.exp(x[mask0]))
out[mask1] = x[mask1] + np.log1p(np.exp(-x[mask1]))
return out
if x > 0:
return x + np.log1p(np.exp(-x))
else:
return np.log1p(np.exp(x))
def get_mle_data_log_lik_terms(mle_par, x_mat, y_vec, y_g_vec):
beta = mle_par['beta'].get()
# atleast_1d is necessary for indexing by y_g_vec to work right.
e_u = np.atleast_1d(mle_par['u'].get())
# Log likelihood from data.
z = e_u[y_g_vec] + np.squeeze(np.matmul(x_mat, beta))
return y_vec * z - np.log1p(np.exp(z))
def log_1plusexp(eta_):
''' Numerically stable version np.log(1 + np.exp(eta))
eta_ (nd-array): An ndarray that potentially contains high values that
will overflow while taking the exponential
-----------------------------------------------------------------------
returns (nd-array): log(1 + exp(eta_))
'''
eta_original = deepcopy(eta_)
eta_ = np.where(eta_ >= np.log(sys.float_info.max), np.log(sys.float_info.max) - 1, eta_)
return np.where(eta_ >= 50, eta_original, np.log1p(np.exp(eta_)))
def _log_hazard(self, params, T, *Xs):
alpha_params = params[self._LOOKUP_SLICE["alpha_"]]
log_alpha_ = np.dot(Xs[0], alpha_params)
alpha_ = np.exp(log_alpha_)
beta_params = params[self._LOOKUP_SLICE["beta_"]]
log_beta_ = np.dot(Xs[1], beta_params)
beta_ = np.exp(log_beta_)
return log_beta_ - log_alpha_ + np.expm1(log_beta_) * (
np.log(T) - log_alpha_) - np.log1p((T / alpha_)**beta_)
def logaddexp(logA, logB):
"""
Given the log of two matrices A and B as logA and logB, carries out A + B in log space
"""
maxN = np.maximum(logA, logB)
minN = np.minimum(logA, logB)
C = np.log1p(np.exp(minN - maxN)) + maxN
return C
def softplus_stable(x, bias=None, dt=1.0):
if bias is not None:
inp = x + bias
f = np.log1p(np.exp(inp)) * dt
logf = np.log(f)
df = np.exp(inp) / (1.0 + np.exp(inp)) * dt
ddf = np.exp(inp) / (1.0 + np.exp(inp))**2 * dt
return f, logf, df, ddf
def ll(x, num_peds, ess, robot_mu_x, robot_mu_y, ped_mu_x, ped_mu_y, \
cov_robot_x, cov_robot_y, inv_cov_robot_x, inv_cov_robot_y, \
cov_ped_x, cov_ped_y, inv_cov_ped_x, inv_cov_ped_y, \
one_over_cov_sum_x, one_over_cov_sum_y, normalize):
T = np.size(robot_mu_x)
quad_robot_mu_x = np.dot((x[:T]-robot_mu_x).T, np.dot(inv_cov_robot_x, \
x[:T]-robot_mu_x))
quad_robot_mu_y = np.dot((x[T:2*T]-robot_mu_y).T, np.dot(inv_cov_robot_y, \
x[T:2*T]-robot_mu_y))
llambda = -0.5 * quad_robot_mu_x - 0.5 * quad_robot_mu_y
n = 2
for ped in range(ess):
quad_ped_mu_x = np.dot((x[n*T:(n+1)*T]-ped_mu_x[ped]).T, np.dot(\
inv_cov_ped_x[ped], x[n*T:(n+1)*T]-ped_mu_x[ped]))
quad_ped_mu_y = np.dot((x[(n+1)*T:(n+2)*T]-ped_mu_y[ped]).T, np.dot(\
inv_cov_ped_y[ped], x[(n+1)*T:(n+2)*T]-ped_mu_y[ped]))
llambda = llambda - 0.5 * quad_ped_mu_x - 0.5 * quad_ped_mu_y
n = n + 2
n = 2
for ped in range(ess):
# if normalize == True:
# # normalize_x = np.multiply(np.power(2*np.pi,-0.5), \
# one_over_std_sum_x[ped])
# # normalize_y = np.multiply(np.power(2*np.pi,-0.5), \
# one_over_std_sum_y[ped])
# else:
normalize_x = 1.
normalize_y = 1.
vel_x = np.tile(x[:T], (T, 1)).T - np.tile(x[n * T:(n + 1) * T],
(T, 1))
vel_y = np.tile(x[T:2 * T],
(T, 1)).T - np.tile(x[(n + 1) * T:(n + 2) * T], (T, 1))
n = n + 2
vel_x_2 = np.power(vel_x, 2)
vel_y_2 = np.power(vel_y, 2)
quad_robot_ped_x = np.multiply(vel_x_2, one_over_cov_sum_x[ped])
quad_robot_ped_y = np.multiply(vel_y_2, one_over_cov_sum_y[ped])
Z_x = np.multiply(normalize_x, np.exp(-0.5 * quad_robot_ped_x))
Z_y = np.multiply(normalize_y, np.exp(-0.5 * quad_robot_ped_y))
Z = np.multiply(Z_x, Z_y)
log_znot_norm = np.sum(np.log1p(-Z))
llambda = llambda + log_znot_norm
return -1. * llambda
def _log_logistic_sigmoid(x_real):
''' Compute log of logistic sigmoid transform from real line to unit interval.
Numerically stable and fully vectorized.
Args
----
x_real : array-like, with values in (-infty, +infty)
Returns
-------
log_p_real : array-like, size of x_real, with values in <= 0
'''
if not isinstance(x_real, float):
out = np.zeros_like(x_real)
mask1 = x_real > 50.0
out[mask1] = - np.log1p(np.exp(-x_real[mask1]))
mask0 = np.logical_not(mask1)
out[mask0] = x_real[mask0]
out[mask0] -= np.log1p(np.exp(x_real[mask0]))
return out
return _log_logistic_sigmoid_not_vectorized(x_real)
def multivariate_studentst_logpdf(data, mus, Sigmas, nus, Ls=None):
"""
Compute the log probability density of a multivariate Student's t distribution.
This will broadcast as long as data, mus, Sigmas, nus have the same (or at
least be broadcast compatible along the) leading dimensions.
Parameters
----------
data : array_like (..., D)
The points at which to evaluate the log density
mus : array_like (..., D)
The mean(s) of the t distribution(s)
Sigmas : array_like (..., D, D)
The covariances(s) of the t distribution(s)
nus : array_like (...,)
The degrees of freedom of the t distribution(s)
Ls : array_like (..., D, D)
Optionally pass in the Cholesky decomposition of Sigmas
Returns
-------
lps : array_like (...,)
Log probabilities under the multivariate Gaussian distribution(s).
"""
# Check inputs
D = data.shape[-1]
assert mus.shape[-1] == D
assert Sigmas.shape[-2] == Sigmas.shape[-1] == D
if Ls is not None:
assert Ls.shape[-2] == Ls.shape[-1] == D
else:
Ls = np.linalg.cholesky(Sigmas) # (..., D, D)
# Quadratic term
q = batch_mahalanobis(Ls, data - mus) / nus # (...,)
lp = -0.5 * (nus + D) * np.log1p(q) # (...,)
# Normalizer
lp = lp + gammaln(0.5 * (nus + D)) - gammaln(0.5 * nus) # (...,)
lp = lp - 0.5 * D * np.log(np.pi) - 0.5 * D * np.log(nus) # (...,)
L_diag = np.reshape(Ls, Ls.shape[:-2] + (-1, ))[..., ::D + 1] # (..., D)
half_log_det = np.sum(np.log(abs(L_diag)), axis=-1) # (...,)
lp = lp - half_log_det
return lp
def log_prior(self, x, w):
'''
Returns log(p(Y|x,w))
'''
n = x.shape[0]
if self.prior_model == "logistic_regression":
negative_energy = np.dot(x, w)
return np.vstack(
(-np.log1p(np.exp(negative_energy)) * np.ones(x.shape[0]),
negative_energy - np.log1p(np.exp(negative_energy)))).T
elif self.prior_model == "mlp":
cur_idx = self.n_features * self.hidden_layer_sizes[0]
wi = w[:cur_idx].reshape(
(self.n_features, self.hidden_layer_sizes[0]))
bi = w[cur_idx:cur_idx + self.hidden_layer_sizes[0]]
ho = np.dot(x, wi) + bi
hi = np.tanh(ho)
cur_idx += self.hidden_layer_sizes[0]
for i in range(len(self.hidden_layer_sizes) - 1):
wi = w[cur_idx:cur_idx + self.hidden_layer_sizes[i] *
self.hidden_layer_sizes[i + 1]].reshape(
(self.hidden_layer_sizes[i],
self.hidden_layer_sizes[i + 1]))
cur_idx += self.hidden_layer_sizes[
i] * self.hidden_layer_sizes[i + 1]
bi = w[cur_idx:cur_idx + self.hidden_layer_sizes[i + 1]]
cur_idx += self.hidden_layer_sizes[i + 1]
ho = np.dot(hi, wi) + bi
hi = np.tanh(ho)
# cur_idx = cur_idx+self.n_hidden_units**2
negative_energy = np.dot(hi, w[cur_idx:-1]) + w[-1]
negative_energy = np.vstack((np.zeros(n), negative_energy)).T
return negative_energy - logsumexp(negative_energy,
axis=1).reshape((n, 1))
else:
raise ValueError("Invalid prior model: %s" % self.prior_model)
def simulate_ramping(beta=np.linspace(-0.02, 0.02, 5),
w2=3e-3,
x0=0.5,
C=40,
T=100,
bin_size=0.01):
NC = 5 # number of trial types
cohs = np.arange(NC)
trial_cohs = np.repeat(cohs, int(T / NC))
tr_lengths = np.random.randint(50, size=(T)) + 50
us = []
xs = []
zs = []
ys = []
for t in range(T):
tr_coh = trial_cohs[t]
betac = beta[tr_coh]
tr_length = tr_lengths[t]
x = np.zeros(tr_length)
z = np.zeros(tr_length)
x[0] = x0 + np.sqrt(w2) * npr.randn()
z[0] = 0
for i in np.arange(1, tr_length):
if x[i - 1] >= 1.0:
x[i] = 1.0
z[i] = 1
else:
x[i] = np.min(
(1.0, x[i - 1] + betac + np.sqrt(w2) * npr.randn()))
if x[i] >= 1.0:
z[i] = 1
else:
z[i] = 0
y = npr.poisson(np.log1p(np.exp(C * x)) * bin_size)
u = np.tile(one_hot(tr_coh, 5), (tr_length, 1))
us.append(u)
xs.append(x.reshape((tr_length, 1)))
zs.append(z.reshape((tr_length, 1)))
ys.append(y.reshape((tr_length, 1)))
return ys, xs, zs, us, tr_lengths, trial_cohs
def get_log_lik(self):
beta = self.glmm_par_draw['beta'].get()
u = self.glmm_par_draw['u'].get()
mu = self.glmm_par_draw['mu'].get()
tau = self.glmm_par_draw['tau'].get()
log_tau = np.log(tau)
log_lik = 0.
# Log likelihood from data.
z = u[self.y_g_vec] + np.matmul(self.x_mat, beta)
log_lik += np.sum(self.y_vec * z - np.log1p(np.exp(z)))
# Log likelihood from random effect terms.
log_lik += -0.5 * tau * np.sum((mu - u) ** 2) + 0.5 * log_tau * len(u)
return log_lik
def get_e_logistic_term(y, z_mean, z_sd, std_draws):
assert z_sd.ndim == y.ndim
assert z_mean.ndim == y.ndim
# The last axis will be the standard draws axis.
draws_axis = z_sd.ndim
z_draws = \
np.expand_dims(z_sd, axis=draws_axis) * std_draws + \
np.expand_dims(z_mean, axis=draws_axis)
# By dividing by the number of standard draws after summing,
# we add the sample means for all the observations.
# Note that
# log(1 - p) = log(1 / (1 + exp(z))) = -log(1 + exp(z))
logit_term = \
np.sum(np.log1p(np.exp(z_draws))) / std_draws.size
return np.sum(y * z_mean) - logit_term
def ll(x, T, robot_mu_x, robot_mu_y, \
ped_mu_x, ped_mu_y, \
inv_cov_robot_x, inv_cov_robot_y, \
inv_cov_ped_x, inv_cov_ped_y, \
one_over_cov_sum_x, one_over_cov_sum_y, normalize):
quad_robot_mu_x = np.dot((x[:T]-robot_mu_x).T, np.dot(\
inv_cov_robot_x, x[:T]-robot_mu_x))
quad_robot_mu_y = np.dot((x[T:2*T] - robot_mu_y).T, np.dot( \
inv_cov_robot_y, x[T:2*T] - robot_mu_y))
llambda = -0.5 * quad_robot_mu_x - 0.5 * quad_robot_mu_y
n = 2
quad_ped_mu_x = np.dot((x[n*T:(n+1)*T]-ped_mu_x).T, np.dot(inv_cov_ped_x,\
x[n*T:(n+1)*T]-ped_mu_x))
quad_ped_mu_y = np.dot((x[(n+1)*T:(n+2)*T]-ped_mu_y).T, np.dot(inv_cov_ped_y,\
x[(n+1)*T:(n+2)*T]-ped_mu_y))
llambda = llambda - 0.5 * quad_ped_mu_x - 0.5 * quad_ped_mu_y
n = 2
# if normalize == True:
# normalize_x = np.multiply(np.power(2*np.pi, -0.5), \
# np.diag(one_over_std_sum_x))
# normalize_y = np.multiply(np.power(2*np.pi, -0.5), \
# np.diag(one_over_std_sum_y))
# else:
normalize_x = 1.
normalize_y = 1.
vel_x = x[:T] - x[n * T:(n + 1) * T]
vel_y = x[T:2 * T] - x[(n + 1) * T:(n + 2) * T]
vel_x_2 = np.power(vel_x, 2)
vel_y_2 = np.power(vel_y, 2)
quad_robot_ped_x = np.multiply(vel_x_2, np.diag(one_over_cov_sum_x))
quad_robot_ped_y = np.multiply(vel_y_2, np.diag(one_over_cov_sum_y))
Z_x = np.multiply(normalize_x, np.exp(-0.5 * quad_robot_ped_x))
Z_y = np.multiply(normalize_y, np.exp(-0.5 * quad_robot_ped_y))
Z = np.multiply(Z_x, Z_y)
log_znot_norm = np.sum(np.log1p(-Z))
llambda = llambda + log_znot_norm
return -1. * llambda
def _cumulative_hazard(self, params, times):
alpha_, beta_ = params
return np.log1p((times / alpha_) ** beta_)
def test_log1p():
fun = lambda x : 3.0 * np.log1p(x)
d_fun = grad(fun)
check_grads(fun, abs(npr.randn()))
check_grads(d_fun, abs(npr.randn()))
def _log_hazard(self, params, T, *Xs):
alpha_params = params[self._LOOKUP_SLICE["alpha_"]]
log_alpha_ = np.dot(Xs[0], alpha_params)
alpha_ = np.exp(log_alpha_)
beta_params = params[self._LOOKUP_SLICE["beta_"]]
log_beta_ = np.dot(Xs[1], beta_params)
beta_ = np.exp(log_beta_)
return log_beta_ - log_alpha_ + np.expm1(log_beta_) * (np.log(T) - log_alpha_) - np.log1p((T / alpha_) ** beta_)
def _log_1m_sf(self, params, times):
alpha_, beta_ = params
return -np.log1p((times / alpha_) ** -beta_)
def test_log1p():
fun = lambda x : 3.0 * np.log1p(x)
check_grads(fun)(abs(npr.randn()))
