def optimize(self, curb=None):
assert hasattr(self, "inputs")
assert hasattr(self, "targets")
x = np.atleast_2d(self.inputs)
y = np.atleast_2d(self.targets)
assert len(x) == len(y)
n, D = x.shape
n, E = y.shape
if curb is not None:
self.curb = curb
elif not hasattr(self, "curb"):
self.curb = Empty()
self.curb.snr = 500
self.curb.ls = 100
self.curb.std = std(x, 0)
if not hasattr(self, "hyp"):
self.hyp = np.zeros([E, D + 2])
self.hyp[:, :D] = np.repeat(log(std(x, 0)).reshape(1, D), E, 0)
self.hyp[:, D] = log(std(y, 0))
self.hyp[:, -1] = log(std(y, 0) / 10)
print("Train hyperparameters of full GP...")
try:
self.result = minimize(
value_and_grad(self.hyp_crub), self.hyp, jac=True)
except Exception:
self.result = minimize(
value_and_grad(self.hyp_crub), self.hyp, jac=True, method='CG')
self.hyp = self.result.get('x').reshape(E, -1)
self.cache()
def regression_data(seed, data_count=500):
"""
Generate data from a noisy sine wave.
:param seed: random number seed
:param data_count: number of data points.
:return:
"""
np.random.seed(seed)
noise_var = 0.1
x = np.linspace(-4, 4, data_count)
y = 1 * np.sin(x) + np.sqrt(noise_var) * npr.randn(data_count)
train_count = int(0.2 * data_count)
idx = npr.permutation(range(data_count))
x_train = x[idx[:train_count], np.newaxis]
x_test = x[idx[train_count:], np.newaxis]
y_train = y[idx[:train_count]]
y_test = y[idx[train_count:]]
mu = np.mean(x_train, 0)
std = np.std(x_train, 0)
x_train = (x_train - mu) / std
x_test = (x_test - mu) / std
mu = np.mean(y_train, 0)
std = np.std(y_train, 0)
y_train = (y_train - mu) / std
train_stats = dict()
train_stats['mu'] = mu
train_stats['sigma'] = std
return x_train, y_train, x_test, y_test, train_stats
def standardize(self):
zscore = lambda x, mu, sigma: (x - mu.reshape(1, -1)) / sigma.reshape(
1, -1)
un_zscore = lambda x, mu, sigma: x * sigma.reshape(1, -1) + mu.reshape(
1, -1)
if not self.standardized:
self.mu_x = np.mean(self.x_train, axis=0)
self.sigma_x = np.std(self.x_train, axis=0)
self.x_train = zscore(self.x_train, self.mu_x, self.sigma_x)
if self.x_test is not None:
self.x_test = zscore(self.x_test, self.mu_x, self.sigma_x)
if self.family == 'gaussian':
#self.mu_f = np.mean(self.f_train, axis=0)
#self.sigma_f = np.std(self.f_train, axis=0)
self.mu_y = np.mean(self.y_train, axis=0)
self.sigma_y = np.std(self.y_train, axis=0)
self.f_train = zscore(self.f_train, self.mu_y, self.sigma_y)
if self.f_test is not None:
self.f_test = zscore(self.f_test, self.mu_y, self.sigma_y)
self.y_train = zscore(self.y_train, self.mu_y, self.sigma_y)
if self.y_test is not None:
self.y_test = zscore(self.y_test, self.mu_y, self.sigma_y)
self.f_orig = self.f
self.f = lambda x: zscore(
self.f_orig(un_zscore(x, self.mu_x, self.sigma_x)), self.
mu_y, self.sigma_y)
self.standardized = True
def summarize_res(sname, datasize):
print(sname)
res = []
times = []
for i in range(100):
PATH = ROOT_PATH + "/MMR_IVs/results/zoo/" + sname + "/"
filename = os.path.join(
PATH, str(date.today()),
'LMO_errs_{}_nystr_prodkern_{}.npy'.format(i, datasize))
if os.path.exists(filename):
tmp_res = np.load(filename, allow_pickle=True)
if tmp_res[-1] is not None:
res += [tmp_res[-1]]
time_path = os.path.join(
PATH, str(date.today()),
'/LMO_errs_{}_nystr_prodkern_{}_time.npy'.format(i, datasize))
if os.path.exists(time_path):
t = np.load(time_path)
times += [t]
res = np.array(res)
times = np.array(times)
res = remove_outliers(res)
times = np.sort(times)[:80]
print(times)
print('mean, std: ', np.mean(res), np.std(res))
print('time: ', np.mean(times), np.std(times))
def rand_theta(self, scale):
theta = scale * np.random.randn(self.num_param)
theta[0] = np.log(np.std(self.train_y)/2)
theta[1] = np.log(np.std(self.train_y))
for i in range(self.dim):
theta[2+i] = np.maximum(-100, np.log(0.5*(self.train_x[i].max() - self.train_x[i].min())))
return theta
def __init__(self,
train_x,
train_y,
layer_sizes,
activations,
bfgs_iter=100,
l1=0,
l2=0,
debug=False):
self.train_x = np.copy(train_x)
self.train_y = np.copy(train_y)
self.dim = train_x.shape[0]
self.num_train = train_x.shape[1]
self.nn = NN(layer_sizes, activations)
self.num_param = 2 + self.dim + self.nn.num_param(self.dim)
self.bfgs_iter = bfgs_iter
self.l1 = l1
self.l2 = l2
self.debug = debug
self.m = layer_sizes[-1]
self.in_mean = np.mean(self.train_x, axis=1)
self.in_std = np.std(self.train_x, axis=1)
self.train_x = ((self.train_x.T - self.in_mean) / self.in_std).T
self.out_mean = np.mean(self.train_y)
self.out_std = np.std(self.train_y)
self.train_y = (self.train_y - self.out_mean) / self.out_std
self.loss = np.inf
def get_default_theta(self):
theta = np.random.randn(4 + self.dim)
for i in range(self.dim):
theta[1+i] = np.maximum(-100, np.log(0.5*(self.train_x[i].max() - self.train_x[i].min()))) #length scale
theta[self.dim+1] = np.log(np.std(self.src_y)) # sigma2_src
theta[self.dim+2] = np.log(np.std(self.tag_y)) # sigma2_tag
theta[self.dim+3] = 2 * np.random.random(1) - 1 # -1< lambda <1
return theta
def getNoise(self):
#estimate based off of vals less than 3 sigma above mean
#did a couple of spot checks and this works pretty well, need more rigor in future
noi = np.std(self.data[self.data < np.average(self.data) +
2 * np.std(self.data)])
print('noise is:')
print(noi)
return noi
def test_logitnormal_moments(self):
# global parameters for computing lognormals
gh_loc, gh_weights = hermgauss(4)
# log normal parameters
lognorm_means = np.random.random((5, 3)) # should work for arrays now
lognorm_infos = np.random.random((5, 3))**2 + 1
alpha = 2 # dp parameter
# draw samples
num_draws = 10**5
samples = np.random.normal(lognorm_means,
1/np.sqrt(lognorm_infos), size = (num_draws, 5, 3))
logit_norm_samples = sp.special.expit(samples)
# test lognormal means
np_test.assert_allclose(
np.mean(logit_norm_samples, axis = 0),
ef.get_e_logitnormal(
lognorm_means, lognorm_infos, gh_loc, gh_weights),
atol = 3 * np.std(logit_norm_samples) / np.sqrt(num_draws))
# test Elog(x) and Elog(1-x)
log_logistic_norm = np.mean(np.log(logit_norm_samples), axis = 0)
log_1m_logistic_norm = np.mean(np.log(1 - logit_norm_samples), axis = 0)
tol1 = 3 * np.std(np.log(logit_norm_samples))/ np.sqrt(num_draws)
tol2 = 3 * np.std(np.log(1 - logit_norm_samples))/ np.sqrt(num_draws)
np_test.assert_allclose(
log_logistic_norm,
ef.get_e_log_logitnormal(
lognorm_means, lognorm_infos, gh_loc, gh_weights)[0],
atol = tol1)
np_test.assert_allclose(
log_1m_logistic_norm,
ef.get_e_log_logitnormal(
lognorm_means, lognorm_infos, gh_loc, gh_weights)[1],
atol = tol2)
# test prior
prior_samples = np.mean((alpha - 1) *
np.log(1 - logit_norm_samples), axis = 0)
tol3 = 3 * np.std((alpha - 1) * np.log(1 - logit_norm_samples)) \
/np.sqrt(num_draws)
np_test.assert_allclose(
prior_samples,
ef.get_e_dp_prior_logitnorm_approx(
alpha, lognorm_means, lognorm_infos, gh_loc, gh_weights),
atol = tol3)
x = np.random.normal(0, 1e2, size = 10)
def e_log_v(x):
return np.sum(ef.get_e_log_logitnormal(\
x[0:5], np.abs(x[5:10]), gh_loc, gh_weights)[0])
check_grads(e_log_v, order=2)(x)
def mean_std(self):
"""Compute the average standard deviation """
#Gaussian width = mean of stds of all dimensions
X, Y = self.xy()
stdx = np.mean(np.std(X, 0))
stdy = np.mean(np.std(Y, 0))
mstd = old_div((stdx + stdy), 2.0)
return mstd
def rand_theta(self, scale):
theta = scale * np.random.randn(self.num_param)
theta[0] = 1.0
theta[1] = np.log(np.std(self.low_y))
theta[2] = np.log(np.std(self.high_y))
for i in range(self.dim):
theta[4+i] = np.maximum(-100, np.log(0.5*(self.low_x[i].max() - self.low_x[i].min())))
theta[5+self.dim+i] = np.maximum(-100, np.log(0.5*(self.high_x[i].max() - self.high_x[i].min())))
return theta
def Fit(self, X, Y, **kwargs):
if self.ignore_X:
self.Xmean = 0
self.Xsigma = 1
else:
self.Xmean = np.mean(X, axis=0)
self.Xsigma = np.std(X, axis=0)
self.Ymean = np.mean(Y, axis=0)
self.Ysigma = np.std(Y, axis=0)
def rand_theta(self, scale=0.1):
"""
Generate an initial theta, the weights of NN are randomly initialized
"""
theta = scale * np.random.randn(self.num_param)
theta[0] = np.log(np.std(self.train_y) / 2)
theta[1] = np.log(np.std(self.train_y))
for i in range(self.dim):
theta[2 * + i] = np.maximum(-100, np.log(0.5 * (self.train_x[i, :].max() - self.train_x[i, :].min())))
return theta
def evaluate(self, n_trajectories, print_reward=False):
"""
Evaluate the deterministic policy for N full trajectories.
:param n_trajectories: number of trajectories to use for the evaluation.
:return (cumulative_reward, mean_traj_reward):
"""
total_reward, trajectory = 0, 0
traj_rewards = []
traj_reward = 0
state = self.env.reset()
φ_s = self.φ_fn(state)
step = 0
actions = []
states = []
print('Evaluating the deterministic policy...')
while len(traj_rewards) < n_trajectories:
step += 1
action = π(φ_s, θ=self.θ, Σ=self.Σ, deterministic=True)
states.append(state)
actions.append(action)
next_state, reward, done, _ = self.env.step(action)
total_reward += reward
traj_reward += reward
if self.render:
self.env.render()
if done:
# print(step)
step = 0
φ_s = self.φ_fn(self.env.reset())
trajectory += 1
traj_rewards.append(traj_reward)
traj_reward = 0
if print_reward:
# print(traj_rewards)
print(len(traj_rewards), 'trajectories: total',
total_reward, 'mean', np.mean(traj_rewards), 'std',
np.std(traj_rewards), 'max', np.max(traj_rewards))
#print('states', states)
#print('actions', actions)
# print()
states = []
actions = []
else:
state = next_state
φ_s = self.φ_fn(next_state)
mean_traj_reward = total_reward / n_trajectories
if print_reward:
print('FINAL: total', total_reward, 'mean', np.mean(traj_rewards),
'std', np.std(traj_rewards), 'max', np.max(traj_rewards))
print()
return total_reward, mean_traj_reward
def __str__(self):
mean_y1 = np.mean(self.Y1, 0)
std_y1 = np.std(self.Y1, 0)
mean_y2 = np.mean(self.Y2, 0)
std_y2 = np.std(self.Y2, 0)
prec = 4
desc = ''
desc += 'E[y1] = %s; ' % (np.array_str(mean_y1, precision=prec))
desc += 'E[y2] = %s; ' % (np.array_str(mean_y2, precision=prec))
desc += 'Std[y1] = %s; ' % (np.array_str(std_y1, precision=prec))
desc += 'Std[y2] = %s; ' % (np.array_str(std_y2, precision=prec))
return desc
def rand_theta(self, scale=1):
'''
generate an initial theta, the weights of NN are randomly initialized
'''
theta = scale * np.random.randn(self.num_param)
theta[0] = np.log(np.std(self.train_y_zero) / 2)
theta[1] = np.log(np.std(self.train_y_zero))
for i in range(self.dim):
theta[2 + i] = np.maximum(
-100,
np.log(0.5 * (self.train_x[i].max() - self.train_x[i].min())))
return theta
def __str__(self):
mean_x = np.mean(self.X, 0)
std_x = np.std(self.X, 0)
mean_y = np.mean(self.Y, 0)
std_y = np.std(self.Y, 0)
prec = 4
desc = ''
desc += 'E[x] = %s \n' % (np.array_str(mean_x, precision=prec))
desc += 'E[y] = %s \n' % (np.array_str(mean_y, precision=prec))
desc += 'Std[x] = %s \n' % (np.array_str(std_x, precision=prec))
desc += 'Std[y] = %s \n' % (np.array_str(std_y, precision=prec))
return desc
def get_init_hyperparams(self) -> tuple:
"""
Compute initial hyperparameters for dynamics GP
:return: [length scales, signal variance, noise variance]
"""
length_scales = np.repeat(np.log(
np.std(self.state_action_pairs, axis=0)).reshape(1, -1),
self.state_dim,
axis=0)
sigma_f = np.log(np.std(self.state_delta, axis=0))
sigma_eps = np.log(np.std(self.state_delta, axis=0) / 10)
return length_scales, sigma_f, sigma_eps
def rand_theta(self, scale=1):
"""
Generate an initial theta, the weights of NN are randomly initialized
"""
theta = scale * np.random.randn(self.num_param)
# noises and self covariances
for i in range(self.num_obj):
theta[i] = np.log(np.std(self.train_y[:, i]) / 2)
theta[self.num_obj + i] = np.log(np.std(self.train_y[:, i]))
# lengthscales
for i in range(self.dim):
theta[2 * self.num_obj + i] = np.maximum(-100, np.log(0.5 * (self.train_x[i, :].max() - self.train_x[i, :].min())))
return theta
def load_data(self, csvname):
data = np.loadtxt(csvname, delimiter=',').T
self.x = data[:, :-1:]
self.y = data[:, -1:]
# center input
mean1 = np.mean(self.x[:, 0])
mean2 = np.mean(self.x[:, 1])
std1 = np.std(self.x[:, 0])
std2 = np.std(self.x[:, 1])
self.x[:, 0] -= mean1
self.x[:, 0] /= std1
self.x[:, 1] -= mean2
self.x[:, 1] /= std2
def test_e_log_lik(self):
n_test_samples = 10000
# Our expected log likelihood should only differ from a sample average
# of the generated log likelihood by a constant as the parameters
# vary. Check this using num_param different random parameters.
num_params = 5
ell_by_param = np.full(num_params, float('nan'))
sample_ell_by_param = np.full(num_params, float('nan'))
standard_error = 0.
for i in range(num_params):
tau, nu, phi_mu, phi_var = \
vi.initialize_parameters(num_samples, x_dim, k_approx)
phi_var_expanded = np.array([phi_var for d in range(x_dim)])
# set vb parameters
vb_params2['phi'].set_vector(
np.hstack([np.ravel(phi_mu.T), phi_var]))
vb_params2['pi'].set_vector(np.ravel(tau))
vb_params2['nu'].set_vector(np.ravel(nu))
z_sample, a_sample, pi_sample = \
vi.generate_parameter_draws(nu, phi_mu, phi_var_expanded, \
tau, n_test_samples)
sample_e_log_lik = [
vi.log_lik(x, z_sample[n, :, :], a_sample[n, :, :],
pi_sample[n, :], sigma_eps, sigma_a, alpha,
k_approx) \
for n in range(n_test_samples) ]
sample_ell_by_param[i] = np.mean(sample_e_log_lik)
standard_error = \
np.max([ standard_error,
np.std(sample_e_log_lik) / np.sqrt(n_test_samples) ])
# get moments
e_log_pi1, e_log_pi2, phi_moment1, phi_moment2, nu_moment =\
vi.get_moments_VB(vb_params2)
ell_by_param[i] = vi.exp_log_likelihood(nu_moment, phi_moment1,
phi_moment2, e_log_pi1,
e_log_pi2, sigma_a,
sigma_eps, x, alpha)
print('Mean log likelihood standard error: %0.5f' % standard_error)
self.assertTrue(np.std(ell_by_param - sample_ell_by_param) < \
3. * standard_error)
def runSB(psf, psf_k, imageArray):
nImages = np.shape(imageArray)[2]
results = imageArray * 0
for imageIdx in range(0, nImages):
if imageIdx < start:
continue
grndpath = '/home/moss/SMLM/data/fluorophores/frames/' + str(
imageIdx + 1).zfill(5) + '.csv'
grnd = Table.read(grndpath, format='ascii')
no_source = len(grnd['xnano'])
img = imageArray[:, :, imageIdx]
sub = img - np.average(img[img < np.average(img) + 3 * np.std(img)])
subnorm = sub / np.max(sub)
mock = makeMock(grnd)
#mocknorm = mock/np.max(mock);
sb = SparseBayes(subnorm, psf, psf_k, no_source)
#sb = SparseBayes_alpha(mock,psf,psf_k,no_source);
#sb = SparseBayes_nofft(mock,psf,psf_k,sig_psf,no_source);
#sb = SparseBayes_gaussian(subnorm,psf,psf_k);
results[:, :, imageIdx] = sb.res
s = 'nopri' + str(imageIdx + 1).zfill(5) + '.out'
np.savetxt(s, sb.res)
plt.imshow(results[:, :, imageIdx])
plt.show()
return results
def get_default_theta(self):
if self.k: # kernel2 MF
# sn2 + (output_scale + lengthscale) + (output_scale + lengthscales) * 2
theta = np.random.randn(3 + 2 * self.dim)
theta[2] = np.maximum(
-100,
np.log(0.5 * (self.train_x[self.dim - 1].max() -
self.train_x[self.dim - 1].min())))
for i in range(self.dim - 1):
tmp = np.maximum(
-100,
np.log(0.5 *
(self.train_x[i].max() - self.train_x[i].min())))
theta[4 + i] = tmp
theta[4 + self.dim + i] = tmp
else: # kernel1 RBF
# sn2 + output_scale + lengthscales
theta = np.random.randn(2 + self.dim)
for i in range(self.dim):
theta[2 + i] = np.maximum(
-100,
np.log(0.5 *
(self.train_x[i].max() - self.train_x[i].min())))
theta[0] = np.log(np.std(self.train_y) + 0.000001) # sn2
return theta
def rand_theta(self, scale):
if self.k: # kernel2
# sn2 + (output_scale + lengthscale) + (output_scale + lengthscales) * 2
# 1 + 2 + (1 + self.dim - 1)*2 = 3 + 2*self.dim
theta = scale * np.random.randn(3 + 2 * self.dim)
theta[2] = np.maximum(
-100,
np.log(0.5 * (self.train_x[self.dim - 1].max() -
self.train_x[self.dim - 1].min())))
for i in range(self.dim - 1):
tmp = np.maximum(
-100,
np.log(0.5 *
(self.train_x[i].max() - self.train_x[i].min())))
theta[4 + i] = tmp
theta[4 + self.dim + i] = tmp
else: # kernel1 RBF
# sn2 + output_scale + lengthscales, 1 + 1 + self.dim
theta = scale * np.random.randn(2 + self.dim)
for i in range(self.dim):
theta[2 + i] = np.maximum(
-100,
np.log(0.5 *
(self.train_x[i].max() - self.train_x[i].min())))
theta[0] = np.log(np.std(self.train_y)) # sn2
# theta[1] = np.log(np.std(self.train_y))
return theta
def normalize_array(A):
mean, std = np.mean(A), np.std(A)
A_normed = (A - mean) / std
def restore_function(X):
return X * std + mean
return A_normed, restore_function
def normalize_array(A):
mean, std = np.mean(A), np.std(A)
A_normed = (A - mean) / std
def restore_function(X):
return X * std + mean
return A_normed, restore_function
def _prepare_starting_parameter(self, dataset):
self.d = dimension_datasets[dataset.name]
m = np.mean(dataset.actions_train)
std = np.std(dataset.actions_train)
self.scale = 1e-1
v = std * self.scale
return m, v
def normalizeFeatures(X_train, X_test):
mean_X_train = np.mean(X_train, 0)
std_X_train = np.std(X_train, 0)
std_X_train[ std_X_train == 0 ] = 1
X_train_normalized = (X_train - mean_X_train) / std_X_train
X_test_normalized = (X_test - mean_X_train) / std_X_train
return X_train_normalized, X_test_normalized
def validate(self, X, Y):
testError = []
for i in range(len(X)):
result = self.forward(X[i])
cost = self.getCostValue(result, Y[i])
testError.append(cost)
return np.mean(testError), np.std(testError), testError
def standardize(self, x, y=[]):
# Extract or use existing normal parameters to normalize samples
if len(self.x_mean) == 0:
self.x_mean = np.mean(x, axis=0)
self.x_std = np.std(x, axis=0)
x = (x - self.x_mean) / self.x_std
# Extract or use existing normal parameters to normalize targets if there are any
if len(y) != 0:
if len(self.y_mean) == 0:
self.y_mean = np.mean(y, axis=0)
self.y_std = np.std(y, axis=0)
y = (y - self.y_mean) / self.y_std
return x, y
else:
return x
def check_num_snps(sampled_n_dict,
demo,
num_loci,
mut_rate,
ascertainment_pop=None,
error_matrices=None):
if error_matrices is not None or ascertainment_pop is not None:
# TODO
raise NotImplementedError
#seg_sites = momi.simulate_ms(
# ms_path, demo, num_loci=num_loci, mut_rate=mut_rate)
#sfs = seg_sites.sfs
num_bases = 1000
sfs = demo.simulate_data(sampled_n_dict=sampled_n_dict,
muts_per_gen=mut_rate / num_bases,
recoms_per_gen=0,
length=num_bases,
num_replicates=num_loci)._sfs
n_sites = sfs.n_snps(vector=True)
n_sites_mean = np.mean(n_sites)
n_sites_sd = np.std(n_sites)
# TODO this test isn't very useful because expected_branchlen is not used anywhere internally anymore
n_sites_theoretical = demo.expected_branchlen(sampled_n_dict) * mut_rate
#n_sites_theoretical = momi.expected_total_branch_len(
# demo, ascertainment_pop=ascertainment_pop, error_matrices=error_matrices) * mut_rate
zscore = -np.abs(n_sites_mean - n_sites_theoretical) / n_sites_sd
pval = scipy.stats.norm.cdf(zscore) * 2.0
assert pval >= .05
def _stabilize_x(self):
"""Fix the rotation according to the SVD.
"""
U, _, _ = np.linalg.svd(self.X, full_matrices=False)
L = np.linalg.cholesky(np.cov(U.T) + 1e-6 * np.eye(self.D)).T
self.X = np.linalg.solve(L, U.T).T
self.X /= np.std(self.X, axis=0)
def simulator(theta,N):
#get 500*N exponentials
exponentials = np.random.exponential(1/theta,size=N*M)
#reshape to Nx500
exponentials = np.reshape(exponentials,(N,M))
#get means of the rows
summaries = np.mean(exponentials,1)
std = np.std(exponentials,1)
return summaries, std
def collect_test_losses(num_folds):
# Run this after CV results are in. e.g:
# python -c "from deepmolecule.util import collect_test_losses; collect_test_losses(10)"
results = {}
for net_type in ['conv', 'morgan']:
results[net_type] = []
for expt_ix in range(num_folds):
fname = "Final_test_loss_{0}_{1}.pkl.save".format(expt_ix, net_type)
try:
with open(fname) as f:
results[net_type].append(pickle.load(f))
except IOError:
print "Couldn't find file {0}".format(fname)
print "Results are:"
print results
print "Means:"
print {k : np.mean(v) for k, v in results.iteritems()}
print "Std errors:"
print {k : np.std(v) / np.sqrt(len(v) - 1) for k, v in results.iteritems()}
def calculate_func_mean_and_variance(func_samples): ''' Simple helper function that will calulate the mean and variance of a collection of functions INPUT: func_samples: an nd-array of functions, functions are along the columns OUTPUT: func_mean : the mean function of func_samples func_lower : the lower bound (statistically) of func_samples func_upper : the upper bound (statistically) of func_samples ---------------------------------------------------------------------------- Notes: I use 3sigma variance, where 99.7 of the spread is accounted for. ''' func_mean = np.mean(func_samples,axis=1) func_std = np.std(func_samples,axis=1) func_lower = func_mean-(3*func_std) func_upper = func_mean+(3*func_std) return func_mean, func_lower, func_upper
def plot_runtime(ex, fname, func_xvalues, xlabel, func_title=None):
results = glo.ex_load_result(ex, fname)
value_accessor = lambda job_results: job_results['time_secs']
vf_pval = np.vectorize(value_accessor)
# results['test_results'] is a dictionary:
# {'test_result': (dict from running perform_test(te) '...':..., }
times = vf_pval(results['test_results'])
repeats, _, n_methods = results['test_results'].shape
time_avg = np.mean(times, axis=0)
time_std = np.std(times, axis=0)
xvalues = func_xvalues(results)
#ns = np.array(results[xkey])
#te_proportion = 1.0 - results['tr_proportion']
#test_sizes = ns*te_proportion
line_styles = exglo.func_plot_fmt_map()
method_labels = exglo.get_func2label_map()
func_names = [f.__name__ for f in results['method_job_funcs'] ]
for i in range(n_methods):
te_proportion = 1.0 - results['tr_proportion']
fmt = line_styles[func_names[i]]
#plt.errorbar(ns*te_proportion, mean_rejs[:, i], std_pvals[:, i])
method_label = method_labels[func_names[i]]
plt.errorbar(xvalues, time_avg[:, i], yerr=time_std[:,i], fmt=fmt,
label=method_label)
ylabel = 'Time (s)'
plt.ylabel(ylabel)
plt.xlabel(xlabel)
plt.gca().set_yscale('log')
plt.xlim([np.min(xvalues), np.max(xvalues)])
plt.xticks( xvalues, xvalues)
plt.legend(loc='best')
title = '%s. %d trials. '%( results['prob_label'],
repeats ) if func_title is None else func_title(results)
plt.title(title)
#plt.grid()
return results
def do_shift_CV(num_folds, model, shift_X, shift_y):
from scipy import interp
import matplotlib
import python_utils.python_utils.caching as caching
from sklearn.metrics import roc_curve, auc
import pandas as pd
matplotlib.rcParams.update({'font.size': 16})
fig, ax = plt.subplots()
fpr_points = np.linspace(0.,1.,101)
roc_curves = []
auc_vals = []
log_losses = []
color = 'r'
label = 'asdf'
from sklearn.cross_validation import KFold
outer_cv = sklearn.cross_validation.KFold(len(shift_X), num_folds)
for (i,(train, test)) in enumerate(reversed(list(outer_cv))):
print('cv', i)
shift_X_train, shift_y_train = [shift_X[idx] for idx in train], [shift_y[idx] for idx in train]
shift_X_test, shift_y_test = [shift_X[idx] for idx in test], [shift_y[idx] for idx in test]
model.fit(shift_X_train, shift_y_train)
target_y_test_hat = model.predict(shift_X_test)
source_X_test, target_X_test, source_y_test, target_y_test = shift_Xy_to_matrices(shift_X_test, shift_y_test)
fpr, tpr, thresholds = roc_curve(target_y_test, target_y_test_hat)
log_losses.append(logloss(target_y_test, target_y_test_hat))
caching.fig_archiver.log_text('log_losses')
caching.fig_archiver.log_text(log_losses)
auc_vals.append(auc(fpr,tpr))
caching.fig_archiver.log_text('auc_vals')
caching.fig_archiver.log_text(auc_vals)
roc_curves.append(interp(fpr_points, fpr, tpr))
ax.plot(fpr, tpr, color = color, alpha=0.75, zorder=np.random.random())
caching.fig_archiver.archive_fig(fig)
roc_curves_df = pd.DataFrame(roc_curves, columns=fpr_points)
ax.plot(fpr_points, roc_curves_df.mean(), linewidth=5, color=color, label=label)
ax.set_xlabel('fpr',fontsize=22)
ax.set_ylabel('tpr',fontsize=22)
print(pd.Series(auc_vals), 'mean:', np.mean(auc_vals), 'std:', np.std(auc_vals))
caching.fig_archiver.archive_fig(fig)
def batch_normalize(x):
"""
Batch normalizes the matrix along the data axis.
"""
mbmean = np.mean(x, axis=0, keepdims=True)
return (x - mbmean) / (np.std(x, axis=0, keepdims=True) + 1)
def batch_normalize(activations):
mbmean = np.mean(activations, axis=0, keepdims=True)
return (activations - mbmean) / (np.std(activations, axis=0, keepdims=True) + 1)
if __name__ == '__main__':
random = 1
n_samples = 10
n_samples_to_test = 100
num_pseudo_params = 50
dimensions =[1,1,1]
n_layers = len(dimensions)-1
npr.seed(0) #Randomness comes from KMeans
rs = npr.RandomState(0)
motor = np.genfromtxt('motor.csv', delimiter=',',skip_header = True)
X = motor[:,1]
X = (X - np.mean(X))/(np.std(X))
X = X.reshape(len(X),1)
y = motor[:,2]
y = (y-np.mean(y))/(np.std(y))
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state = 42)
total_num_params, log_likelihood, sample_mean_cov_from_deep_gp, predict_layer_funcs, squared_error, create_deep_map = \
build_deep_gp(dimensions, rbf_covariance, num_pseudo_params, random)
init_params = .1 * npr.randn(total_num_params)
deep_map = create_deep_map(init_params)
init_params = initialize(deep_map,X,num_pseudo_params)
print("Optimizing covariance parameters...")
objective = lambda params: -log_likelihood(params,X,y,n_samples)
def forward_pass(self, data, params):
mean, std = params.get(self.get_params_shape())
data = (data - np.mean(data, axis=1, keepdims=True)) / np.std(data, axis=1, keepdims=True)
return (data * std) + mean
def normalize(v, mean, std):
standard = (v - np.mean(v, 1).reshape(-1, 1)) / np.std(v, 1).reshape(-1, 1)
return standard * std + mean
def simulator(theta,v):
#handle more than one simulation per sample
v = v.reshape(-1,M)
simulations =-np.log(v)/theta
return np.mean(simulations,1), np.std(simulations,1)
star_mags = np.array([du.colors_to_mags(r, c)
for r, c in zip(coadd_df.star_mag_r.values,
coadd_df[['star_color_%s'%c for c in colors]].values)])
gal_mags = np.array([du.colors_to_mags(r, c)
for r, c in zip(coadd_df.gal_mag_r.values,
coadd_df[['gal_color_%s'%c for c in colors]].values)])
# look at galaxy fluxes regressed on stars
x = star_mags[coadd_df.is_star.values]
y = gal_mags[coadd_df.is_star.values]
star_mag_model = LinearRegression()
star_mag_model.fit(x, y)
star_residuals = star_mag_model.predict(x) - y
star_mag_model.res_covariance = np.cov(star_residuals.T)
star_resids = np.std(star_mag_model.predict(x) - y, axis=0)
with open('star_mag_proposal.pkl', 'wb') as f:
pickle.dump(star_mag_model, f)
for i in xrange(5):
plt.scatter(star_mag_model.predict(x)[:,i], y[:,i], label=i, c=sns.color_palette()[i])
plt.legend()
plt.show()
# look at star fluxes regressed on galaxy fluxes
x = gal_mags[~coadd_df.is_star.values]
y = star_mags[~coadd_df.is_star.values]
gal_mag_model = LinearRegression()
gal_mag_model.fit(x, y)
gal_residuals = gal_mag_model.predict(x) - y
num_particles = 10
K=10
convergence=1e-05
paramsAVABC,lower_boundsAVABC,i,all_gradientsAVABC = AVABC(params,num_samples,num_particles,K+40,convergence)
paramsBBVI,lower_boundsBBVI,iBBVI,all_gradientsBBVI = BBVI(params,num_samples,num_particles,K+40,convergence)
print params
print "true mean"
print (k+1.)/(n+2.)
a = k+1
b = n-k+1
print 'i AVABC'
print len(lower_boundsAVABC)
print 'i BBVI'
print len(lower_boundsBBVI)
print 'AVABC gradient std'
print np.std(np.array(all_gradientsAVABC))
print 'BBVI gradient std'
print np.std(np.array(all_gradientsBBVI))
x = np.linspace(0,1,100)
plt.plot(lower_boundsBBVI,label='BBVI S=%i, sim=%i' % (num_samples,num_particles),color='red')
plt.plot(lower_boundsAVABC,label='AVABC S=%i, sim=%i' % (num_samples,num_particles),color='blue')
plt.title('Beta-Bernoulli Lower Bound')
plt.legend(loc=4)
#plt.ylim((-25000,0))
plt.show()
# fig, ax = plt.subplots(1, 1)
# plt.plot(x,beta.pdf(x, a,b),'--',color='red',label='true')
# plt.plot(x,kumaraswamy_pdf(x,params),'-',color='blue',label='VI true likelihood')
plt.plot(x, beta.pdf(x, a,b),label='true posterior',color='green')
plt.plot(x,kumaraswamy_pdf(x,paramsAVABC),label='AVABC',color='blue')
