def fisher_information_matrix(self, params):
"""
Computes the Fisher Information Matrix.
Returns
-------
fisher : ndarray
Fisher Information Matrix
"""
n_params = len(np.atleast_1d(params))
fisher = np.zeros(shape=(n_params, n_params))
if not hasattr(self.mean, 'gradient'):
_grad = lambda mean, argnum, params: jacobian(mean, argnum=argnum)(*params)
else:
_grad = lambda mean, argnum, params: mean.gradient(*params)[argnum]
grad_mean = [_grad(self.mean, i, params) for i in range(n_params)]
for i in range(n_params):
for j in range(i, n_params):
fisher[i, j] = np.nansum(grad_mean[i] * grad_mean[j])
fisher[j, i] = fisher[i, j]
return fisher / self.var
def update_sigma2(y, weights, mu, Sigma):
"""
y[N, G, T] data
weights = [N, G, T]
mu = T
"""
diffs = y - mu
total_weight = np.sum(
weights[:, :, np.newaxis] * np.logical_not(np.isnan(y)))
sigma2 = np.nansum(weights[:, :, np.newaxis] * (diffs ** 2))
total_weight = np.maximum(1e-10, total_weight)
sigma2 = (sigma2 / total_weight) + np.trace(Sigma)
return sigma2, total_weight
def gradient(self, params):
# use the gradient if the model provides it.
# if not, compute it using autograd.
if not hasattr(self.mean, 'gradient'):
_grad = lambda mean, argnum, params: jacobian(mean, argnum)(*params)
else:
_grad = lambda mean, argnum, params: mean.gradient(*params)[argnum]
n_params = len(np.atleast_1d(params))
grad_likelihood = np.array([])
for i in range(n_params):
grad = _grad(self.mean, i, params)
grad_likelihood = np.append(grad_likelihood,
np.nansum(grad * (1 - self.data / self.mean(*params))))
return grad_likelihood
def update_mean(y, sigma2, weights, kernel_params):
"""
y[N, G, T] data
mu [T] means
sigma2 = global noise variance
priors = [T, T]
weights = [N, G]
"""
prior = cov_func(kernel_params, inputs, inputs) + np.eye(T) * 1e-6
weights = weights[:, :, np.newaxis] * np.logical_not(np.isnan(y))
B = np.diag(weights.reshape(-1, T).sum(axis=0) / sigma2)
yB = np.nansum((y * weights / sigma2).reshape(-1, T), axis=0)
Sigma = np.linalg.inv(B + np.linalg.inv(prior))
mu = np.dot(Sigma, yB)
# import pdb; pdb.set_trace()
return mu, Sigma
def fisher_information_matrix(self, params):
n_params = len(np.atleast_1d(params))
fisher = np.zeros(shape=(n_params, n_params))
if not hasattr(self.mean, 'gradient'):
_grad = lambda mean, argnum, params: jacobian(mean, argnum=argnum)(*params)
else:
_grad = lambda mean, argnum, params: mean.gradient(*params)[argnum]
grad_mean = [_grad(self.mean, i, params) for i in range(n_params)]
for i in range(n_params):
for j in range(i, n_params):
fisher[i, j] = np.nansum(grad_mean[i] * self._cov_inv * grad_mean[j])
fisher[j, i] = fisher[i, j]
return fisher
def compress_observations(y, weights):
"""
y [N, G, T]
weights [N, G]
takes convex combination of observations by weights
returns mean and relative precision for each dimension of T
"""
t = y.shape[-1]
compressed_weights = (weights[:, :, np.newaxis] * np.logical_not(
np.isnan(y))).sum(axis=0).sum(axis=0)
compressed_y = np.nansum((y * weights[:, :, np.newaxis] / compressed_weights).reshape(
-1, t), axis=0)
if np.any(np.isnan(compressed_y)):
pdb.set_trace()
return compressed_y, compressed_weights
def update_lambda(y, phi, psi, sigma2s, mus, Sigmas):
"""
y = [N, G, T]
phi = [N, K]
pi = [K]
sigma2 = noise variance
mus = [K, L, T]
Sigmas = [K, L, T, T]
"""
lam = np.zeros((G, L))
for l in range(L):
for k in range(K):
ll = np.nansum(norm.logpdf(
y, mus[k, l], np.sqrt(sigma2s[k, l])), axis=-1) # N, G
ll = (ll - 0.5 * np.trace(Sigmas[k, l] / (sigma2s[k, l])))
ll = ll * phi[:, k][:, np.newaxis]
lam[:, l] = lam[:, l] + ll.sum(axis=0)
lam = lam + np.log(psi)
lam = np.exp(lam - logsumexp(lam)[:, np.newaxis])
lam = surgery(lam)
return lam
def update_phi(y, lam, pi, sigma2s, mus, Sigmas):
"""
y = [N, G, T]
lam = [G, L]
pi = [K]
sigma2 = noise variance
mus = [K, L, T]
Sigmas = [K, L, T, T]
"""
phi = np.zeros((N, K))
for k in range(K):
for l in range(L):
ll = np.nansum(norm.logpdf(
y, mus[k, l], np.sqrt(sigma2s[k, l])), axis=-1)
ll = (ll - (0.5 * np.trace(Sigmas[k, l]) / (sigma2s[k, l])))
ll = ll * lam[:, l]
phi[:, k] = phi[:, k] + ll.sum(axis=1)
phi = phi + np.log(pi)
phi = np.exp(phi - logsumexp(phi)[:, np.newaxis])
phi = surgery(phi)
return phi
def evaluate(self, params):
"""
Computes the negative of the log likelihood function.
Parameters
----------
params : ndarray
parameter vector of the mean model and covariance matrix
"""
if callable(self.cov):
theta = params[:self.dim] # mean model parameters
alpha = params[self.dim:] # kernel parameters (hyperparameters)
mean = self.mean(*theta)
cov = self.cov(*alpha)
self._cov_inv = np.linalg.inv(cov)
else:
mean = self.mean(*params)
cov = self.cov
residual = self.data - mean
return (np.linalg.slogdet(cov)[1]
+ np.nansum(residual * (self._cov_inv * residual.T)))
def multinomial_entropy(p):
return -1 * np.nansum(p * np.log(p))
def sum_to_1(r):
R = r.reshape((r.shape[0], -1))
R = R / np.nansum(R[:, ~np.isnan(R.sum(0))], axis=1)[:, np.newaxis]
return R
def evaluate(self, params):
return np.nansum((self.data - self.mean(*params))**2 / (2 * self.var))
def evaluate(self, params):
return np.nansum(
self.mean(*params) - self.data * np.log(self.mean(*params)))
def evaluate(self, params):
r = self.data - self.mean(*params)
return 0.5 * np.nansum(r * r / self.var)
def gradient(self, theta):
mean_theta = self.mean(*theta)
grad = self.mean.gradient(*theta)
return - np.nansum(self.data * grad / mean_theta
- (1 - self.data) * grad / (1 - mean_theta),
axis=-1)
def _evaluate_w_regularization(self, *params):
return np.nansum(
np.absolute(self.data - self.model(*params[:-1])) +
params[-1] * self.regularization(*params[:-1]))
def sum_to_1(r):
R = r.reshape((r.shape[0], -1))
R = R / np.nansum(R, axis=1)[:, np.newaxis] # changed 8/28
return R
def evaluate(self, params):
return np.nansum(np.abs(self.data - self.mean(*params)) / np.sqrt(.5 * self.var))
def svm_cost(x,data):
# computes cost given parameters (kappa, amplitude[, optionally offset])
return np.nansum((data-svm_fn(*x))**2)
columns=full_contra.columns)
completed_y2 = completed_y2.astype(float).round(0)
#================================================================
# Inverse transform both datasets
#================================================================
for j, colname in enumerate(y.columns):
if colname in le_dict.keys():
completed_y[colname] = le_dict[colname].inverse_transform(
completed_y[colname].astype(int))
completed_y2[colname] = le_dict[colname].inverse_transform(
completed_y2[colname].astype(int))
assert np.nansum(
np.abs(completed_y[~nan_mask].astype(float) -
full_contra[~nan_mask].astype(float))) == 0
assert np.nansum(
np.abs(completed_y2[~nan_mask].astype(float) -
full_contra[~nan_mask].astype(float))) == 0
# Mimick the format
completed_y = completed_y.astype(int)
completed_y2 = completed_y2.astype(int)
#completed_y2.to_csv(res + 'Run' + str(run_idx) + '/imp' + dataset_name + '.csv', index = False)
#================================================================
# Diagnostic
#================================================================
def evaluate(self, theta):
p = self.mean(*theta)
N0 = np.exp(-self.data ** 2 / (2 * self.var))
N1 = np.exp(-(self.data - 1) ** 2 / (2 * self.var))
return -np.nansum(np.log((1 - p) * N0 + p * N1))
def evaluate(self, theta):
mean_theta = self.mean(*theta)
return - np.nansum(self.data * np.log(mean_theta)
+ (1. - self.data) * np.log(1. - mean_theta))
def n_counts(self):
"""
Returns the sum of the number of counts over all bin.
"""
return np.nansum(self.data)
def sum_to_1(r):
R = r.reshape((r.shape[0],-1))
#R = R/np.nansum(R[:,~np.isnan(R.sum(0))],axis=1)[:,np.newaxis]
R = R/np.nansum(R,axis=1)[:,np.newaxis] # changed 8/28
return R
def _evaluate_wo_regularization(self, *params):
return np.nansum(np.absolute(self.data - self.model(*params)))
