def re_processing(url_load, url_re):
# url_load gives the url for loading the optimal weight of NN.
# url_re gives the url for saving the computed relative errors.
global inputs, targets
data = np.load(url_load)
opt_weights = data['optweights'].item()
x_scaler = data['x_scaler'].item()
y_scaler = data['y_scaler'].item()
RelativeError = []
for datafile in range(8000):
x_traj_test, y_traj_test = sample_multitraj(datafile, datafile+1)
inputs = x_scaler.transform(x_traj_test)
targets = y_scaler.transform(y_traj_test)
outputs = nn_encode_foward_decode(opt_weights, inputs)
outputs = y_scaler.inverse_transform(outputs)
targets = y_scaler.inverse_transform(targets)
re = np.mean([np.linalg.norm(targets[i] - outputs[i]) / np.linalg.norm(targets[i]) for i in range(len(targets))])
print('sample {:d} relative training norm error {:+1.4e}'.format(datafile, re))
RelativeError.append(re)
np.savez(url_re, re = RelativeError, url_load = url_load)
def sample_with_progress(repeats, n_samps, n_steps, epsilon, path=None):
if path is not None:
dirname = os.path.dirname(path)
if not os.path.exists(dirname):
os.makedirs(dirname)
last = np.random.randn(D)
timestamps = []
all_samples = []
nfevals = []
for i in range(repeats):
timestamps.append(time())
samples = hmc(lnpdf,
x0=last,
n_samples=int(n_samps),
n_steps=n_steps,
epsilon=epsilon)
last = samples[-1]
nfevals.append(lnpdf.counter)
all_samples.append(samples)
if path is not None:
np.savez(path + '_iter' + str(i),
samples=last,
timestamps=timestamps,
nfevals=nfevals)
timestamps.append(time())
if path is not None:
np.savez(path,
samples=all_samples,
timestamps=timestamps,
nfevals=nfevals)
def save(self, desc=""):
fn = self.default_file_name()
if len(desc) != 0:
fn += "_%s" % desc
np.savez(fn, gen=self.model.ps)
return fn
def generate_dataset(self, cachefile='data/decoy-mnist.npz'):
if cachefile and os.path.exists(cachefile):
cache = np.load(cachefile)
data = tuple([cache[f] for f in sorted(cache.files)])
else:
data = self._generate_dataset(os.path.dirname(cachefile))
if cachefile:
np.savez(cachefile, *data)
self.Xr, self.X, self.y, self.E, self.Xtr, self.Xt, self.yt, self.Et = data
self.status.initialized = True
def run():
# train and save the neural network
global inputs, targets, training_error
training_error = []
# max number of iterations in optimization
num_iters = 100
N = 100 # Number of uniformly sampled trajectories in training data set.
# sample training data
# x_traj, y_traj, index = randomsample(N)
x_traj, y_traj, index = shufflesample(N*10, sampling_rate = 0.1)
# normalize the training data
x_scaler = MinMaxScaler((-1,1))
x_scaler.fit(x_traj)
y_scaler = MinMaxScaler((-1,1))
y_scaler.fit(y_traj)
x_traj_scale = x_scaler.transform(x_traj)
y_traj_scale = y_scaler.transform(y_traj)
inputs = x_traj_scale
targets = y_traj_scale
# Decide NN architecture
D = x_traj.shape[1]
G = 20
init_weights = initialize_weights(G, D)
print('---------- Optimizing KOOPMAN NEURAL NET for {} iterations ..... \n'.format(num_iters))
# use adam to optimize
opt_weights = adam(grad(objective), init_weights, step_size=0.01, num_iters = num_iters, callback=callback)
# use sgd to optimize
# opt_weights = sgd(grad(objective), init_weights, step_size=0.1, num_iters = num_iters, callback=callback)
print('done')
# save the optimal weights and related parameters
np.savez('data/sample_1/optweights_tanh_minmax_random1000shuffle_G20_layer2_sgd_2.npz', optweights = opt_weights, x_scaler = x_scaler, y_scaler = y_scaler, index = index, training_error = training_error)
# Pick a trajectory and check the prediction of the nn on this trajectory
x_traj_test, y_traj_test = sample_multitraj(6350, 6351)
inputs = x_scaler.transform(x_traj_test)
targets = y_scaler.transform(y_traj_test)
outputs = nn_encode_foward_decode(opt_weights, inputs)
re = np.mean([np.linalg.norm(targets[i] - outputs[i]) / np.linalg.norm(targets[i]) for i in range(len(targets))])
print('Relative training norm error {:+1.4e}'.format(re))
figplot(outputs, url = None )
def save_model(self):
"""Saves a checkpoint of the current model."""
np.savez(
self.checkpoint_path,
epoch=self.epoch,
θ=self.θ,
α=self.α, # policy parameters
η=self.η,
Σ=self.Σ, # dual parameters
fourier_features=(self.fourier_freq,
self.fourier_offset)) # feature parameters
def init_condition(url_init, num = 8000):
# Extract and save the initial conditions from num trajecotries
x = np.zeros((1,4))
print('Initial conditions collection started.')
for j in range(num):
x_traj_test, y_traj_test = sample_multitraj(j, j+1)
x0 = x_traj_test[0,:].reshape((1,4))
x = np.concatenate((x, x0), axis=0)
print('Initial conditions collection finished.')
x = x[1:,:]
np.savez(url_init, x0 = x)
def get_eigval_dict(point_df, trajs, npz_path, network):
if not os.path.exists(npz_path):
eigval_dict = {}
for ii, point_row in point_df.iterrows():
traj_idx = int(point_row["traj_idx"])
step_idx = int(point_row["step_idx"])
theta = trajs[traj_idx]["theta"][step_idx]
hessian = np.squeeze(network.hess(theta))
eigvals = np.linalg.eigvalsh(hessian)
eigval_dict[str(ii) + "_" + str(step_idx)] = eigvals
np.savez(npz_path, **eigval_dict)
else:
eigval_dict = dict(np.load(npz_path))
return eigval_dict
def save_folded(file, folded_val, pattern, **argk):
"""
Save a folded value to a file with its pattern.
Flatten a folded value and save it with its pattern to a file using
``numpy.savez``. Additional keyword arguments will also be saved to the
file.
Parameters
---------------
file: String or file
Follows the conventions of ``numpy.savez``. Note that the ``npz``
extension will be added if it is not present.
folded_val:
The folded value of a parameter.
pattern:
A ``paragami`` pattern for the folded value.
"""
flat_val = pattern.flatten(folded_val, free=False)
pattern_json = pattern.to_json()
np.savez(file, flat_val=flat_val, pattern_json=pattern_json, **argk)
# result = minimize(loss, theta0,
# jac=grad(loss),
# method='L-BFGS-B',
# bounds=bounds,
# options={'disp': True,
# 'maxiter': 5})
# theta1 = result.x
# np.save(minimized_theta_fname, theta1)
# print('theta after initial minimization', theta1)
# print('gradient norm after initial minimization = {}'.format(np.linalg.norm(grad_log_prob(theta1))))
# 5. Run MALA
stepsize = 1e-8
n_steps = 2000
traj, log_probs, grads, acceptance_probabilities, stepsizes = MALA(
theta0,
log_prob,
grad(log_prob),
n_steps=n_steps,
stepsize=stepsize,
adapt_stepsize=True)
np.savez(os.path.join(data_path,
'elemental_types_mala_freesolv_{}.npz'.format(name)),
traj=traj,
grads=grads,
acceptance_probabilities=acceptance_probabilities,
stepsizes=stepsizes)
if b.units[pID][u]['inCortex']:
ccfRegions.append(b.probeCCF[pID]['ISIRegion'])
else:
ccfRegions.append(b.units[pID][u]['ccfRegion'])
uid.append(pID + '_' + u)
else:
print('fit failed for ' + pID + ' ' + u)
# except:
# continue
saveDir = r"C:\Users\svc_ccg\Desktop\Data\analysis"
np.savez(os.path.join(saveDir, expName + '_glmfits.npz'),
modelParams=modelParams,
ccfRegions=ccfRegions,
fittest=test_corr,
uid=uid)
model.save(saveDir, expName + '_glm_model.pkl'
) #save the last model just to have the structure for recreating
elapsedTime = time.time() - startTime
print('\nelapsed time: ' + str(elapsedTime))
spikes = b.units['A']['292']['times']
binned_spikes = binVariable(spikes[spikes < b.lastBehaviorTime],
binwidth)[changeBins]
model = licking_model.Model(dt=binwidth, licks=binned_spikes)
for fname, ffilter in filterList:
model.add_filter(fname, ffilter)
y_L = y_end[np.where(u_sum<=-25)]
d_init = (np.mean([y[:5] for y in ys],axis=(0,1)) / bin_size).reshape((1,N))
C_init = np.hstack((np.mean(y_U,axis=(0,1))[:,None],np.mean(y_L,axis=(0,1))[:,None])) / bin_size - d_init.T
test_acc.emissions.ds[0] = d_init
test_acc.emissions.Cs[0] = C_init
init_params = copy.deepcopy(test_acc.params)
test_acc_vlem = copy.deepcopy(test_acc)
# fit model with particle em
logjoints, all_particles, all_weights = test_acc._fit_particle_em(ys, inputs=us,
N_particles=10, num_iters=2)
final_params = test_acc.params
ssmdm_dir = os.path.expanduser('/tigress/dz5/ssmdm')
save_name = "dual_accumulator_particle_em.npz"
np.savez(os.path.join(ssmdm_dir, save_name), logjoints=logjoints,
all_particles=all_particles, all_weights=all_weights)
final_params=final_params, init_params=init_params)#,
#q_params=q_params, all_ys=all_ys, all_xs=all_xs, all_us=all_us, all_zs=all_zs)
d = np.load("dual_accumulator_particle_em_100.npz", allow_pickle=True)
ys = d["ys"]
us = d["us"]
xs = d["xs"]
zs = d["zs"]
ys = [np.array(y) for y in ys]
us = [np.array(u) for u in us]
init_params = d["init_params"]
final_params = d["final_params"]
all_particles = d["all_particles"]
all_weights = d["all_weights"]
logjoints = d["logjoints"]
def run(self, theta, niter=10, tol=.0001, verbose=False, path=""):
""" runs NPV for ... iterations
mimics npv_run.m from Sam Gershman's original matlab code
USAGE: [F mu s2] = npv_run(nlogpdf,theta,[nIter])
INPUTS:
theta - [N x D+1] initial parameter settings, where
N is the number of components,
D is the number of latent variables in the model,
and the last column contains the log bandwidths (variances)
nIter (optional) - maximum number of iterations (default: 10)
tol (optional) - change in the evidence lower bound (ELBO) for
convergence (default: 0.0001)
OUTPUTS:
F - [nIter x 1] approximate ELBO value at each iteration
mu - [N x D] component means
s2 - [N x 1] component bandwidths
"""
N, Dpp = theta.shape
D = Dpp - 1
# set LBFGS optim arguments
disp = 10 if verbose else None
opts = {
'disp': disp,
'maxiter': 5000,
'gtol': 1e-7,
'ftol': 1e-7
} #, 'factr':1e2}
elbo_vals = np.zeros(niter)
timestamps = []
timestamps.append(time())
for ii in xrange(niter):
elbo_vals[ii] = self.mc_elbo(theta)
print "iteration %d (elbo = %2.4f)" % (ii, elbo_vals[ii])
# first-order approximation (L1): optimize mu, one component at a time
print " ... optimizing mus "
for n in xrange(N):
print " ... %d / %d " % (n, N)
fun, gfun = self.make_elbo1_funs(theta, n)
res = minimize(fun,
x0=theta[n, :D],
jac=gfun,
method='L-BFGS-B',
options=opts)
theta[n, :D] = res.x
#print theta[:,:D]
#print " ... elbo: ", self.mc_elbo(theta)
# second-order approximation (L2): optimize s2
print " ... optimizing sigmas"
mu = theta[:, :D]
h = np.zeros(N)
for n in xrange(N):
# compute Hessian trace using finite differencing or autograd
h[n] = np.sum(np.diag(hessian(self.lnpdf)(mu[n])))
fun, gfun = self.make_elbo2_funs(theta, h)
res = minimize(fun,
x0=theta[:, -1],
jac=gfun,
method='L-BFGS-B',
options=opts)
theta = np.column_stack([mu, res.x])
# mmd_samples = mogsamples(2000, theta)
if (ii % 5 == 0):
timestamps.append(time())
np.savez(path + '/iter' + str(ii) + "of" + str(niter) + ".npz",
timestamps=timestamps,
mu=mu,
sigma=np.exp(theta[:, -1]) + self.s2min,
n_feval=self.lnpdf.counter)
# calculate the approximate ELBO (L2)
#if (ii > 1) and (np.abs(elbo_vals[ii] - elbo_vals[ii-1] < tol))
# TODO check for convergence
#if (ii > 1) and (np.abs(F[ii]-F[ii-1]) < tol)
# break # end % check for convergence
# unpack params and return
mu = theta[:, :D]
s2 = np.exp(theta[:, -1]) + self.s2min
return mu, s2, elbo_vals, theta
for img in np.unique(image_id):
eventsToInclude.append(
(img, [flash_times[image_id == img], 8, 0.8, 0.1, -0.2]))
np.save(os.path.join(saveDir, expName + '_events.npy'), eventsToInclude)
###RUN for entire experiment###
spikeRateThresh = 0.5
unit_data = []
for pID in b.probes_to_analyze:
for u in probeSync.getOrderedUnits(b.units[pID]):
spikes = b.units[pID][u]['times']
binned_spikes = binVariable(spikes[spikes < b.lastBehaviorTime],
binwidth)[changeBins]
if np.sum(spikes < b.lastBehaviorTime
) > spikeRateThresh * b.lastBehaviorTime:
uid = pID + '_' + u
if b.units[pID][u]['inCortex']:
ccfRegion = b.probeCCF[pID]['ISIRegion']
else:
ccfRegion = b.units[pID][u]['ccfRegion']
unit_data.append((uid, ccfRegion, binned_spikes))
np.save(os.path.join(saveDir, expName + '_unitdata.npy'), unit_data)
np.savez(os.path.join(saveDir, expName + '_params.npz'),
lastBehaviorTime=b.lastBehaviorTime,
binwidth=binwidth,
spikeRateThresh=spikeRateThresh)
'maxiter': 5
})
theta1 = result.x
np.save(minimized_theta_fname, theta1)
print('theta after initial minimization', theta1)
print('gradient norm after initial minimization = {}'.format(
np.linalg.norm(grad_log_prob(theta1))))
# 5. Run MALA
stepsize = 1e-7
collision_rate = 1e-1
n_steps = 1000
traj, log_probs = langevin(x0=theta1,
v0=np.random.randn(len(theta1)),
log_prob_fun=log_prob,
grad_log_prob_fun=grad_log_prob,
n_steps=n_steps,
stepsize=stepsize,
collision_rate=collision_rate)
np.savez(os.path.join(
data_path, 'hydrogen_or_not_langevin_freesolv_{}.npz'.format(name)),
traj=traj,
stepsize=stepsize,
log_probs=log_probs,
collision_rate=collision_rate,
n_steps=n_steps,
gaussian_ll=gaussian_ll)
'maxiter': 5
})
theta1 = result.x
np.save(minimized_theta_fname, theta1)
print('theta after initial minimization', theta1)
print('gradient norm after initial minimization = {}'.format(
np.linalg.norm(grad_log_prob(theta1))))
# 5. Run MALA
#stepsize = 1e-3
#collision_rate = np.inf
n_steps = 10000
traj, log_probs, grads, acceptance_probabilities, stepsizes = MALA(
x0=theta1,
stepsize=1e-4,
log_prob_fun=log_prob,
grad_log_prob_fun=grad_log_prob,
n_steps=n_steps,
adapt_stepsize=True)
np.savez(os.path.join(
data_path, 'all_types_independent_mala_freesolv_{}.npz'.format(name)),
traj=traj,
grads=grads,
log_probs=log_probs,
acceptance_probabilities=acceptance_probabilities,
stepsizes=stepsizes)
def run():
global inputs, targets, hyper
num_iters = 2500
x, y, x_traj_val, y_traj_val, u_val, T_val, Ts_val = build_dataset(
'cartpoledata/autosysdata_train2.h5', ver=1)
# u = np.asmatrix(u).T
# trajectory = np.concatenate((x,u), axis = 1)
DoTraining = 1
DoValidation = 1
if DoTraining == 1:
inputs = x
targets = y
Dx = x.shape[1]
G = 20
init_weights = initialize_weights(G, Dx)
print(
'---------- Optimizing KOOPMAN NEURAL NET for {} iterations ..... \n'
.format(num_iters))
opt_weights = adam(grad(objective),
init_weights,
step_size=0.01,
num_iters=num_iters,
callback=callback)
print('done')
np.savez('cartpoledata/train_results_data2_iter2500.npz',
optweights=opt_weights,
initweights=init_weights)
decoded = nn_encode_decode(opt_weights, inputs)
outputs = nn_encode_foward_decode(opt_weights, inputs)
plt.figure()
_ = plt.scatter(targets, outputs, marker='D', c='g', alpha=0.1)
plt.xlabel('targets')
plt.ylabel('outputs')
plt.title('Dynamic Scatter')
plt.grid()
plt.figure()
_ = plt.scatter(inputs, decoded, marker='D', c='b', alpha=0.1)
plt.xlabel('inputs')
plt.ylabel('decoded')
plt.title('Encoding-decoding Scatter')
plt.grid()
plt.figure()
_ = plt.plot(outputs[:, 2])
_ = plt.plot(targets[:, 2])
plt.show()
re = np.mean([
np.linalg.norm(targets[i] - outputs[i]) /
np.linalg.norm(targets[i]) for i in range(len(targets))
])
print('Relative norm error {:+1.4e}'.format(re))
if DoValidation == 1:
if DoTraining != 1:
optdata = np.load('cartpoledata/train_results_data2.npz')
opt_weights = optdata['optweights'].item()
inputs = x_traj_val
targets = y_traj_val
decoded = nn_encode_decode(opt_weights, inputs)
outputs = nn_encode_foward_decode(opt_weights, inputs)
re_val = np.mean([
np.linalg.norm(targets[i] - outputs[i]) /
np.linalg.norm(targets[i]) for i in range(len(targets))
])
print('Relative validation norm error {:+1.4e}'.format(re_val))
plt.figure()
_ = plt.scatter(targets, outputs, marker='D', c='g', alpha=0.1)
plt.xlabel('targets')
plt.ylabel('outputs')
plt.title('Dynamic Scatter')
plt.grid()
plt.figure()
_ = plt.scatter(inputs, decoded, marker='D', c='b', alpha=0.1)
plt.xlabel('inputs')
plt.ylabel('decoded')
plt.title('Encoding-decoding Scatter')
plt.grid()
plt.figure()
_ = plt.plot(outputs[:, 0])
_ = plt.plot(targets[:, 0])
plt.title('Trajectory prediction of x1')
plt.figure()
_ = plt.plot(outputs[:, 1])
_ = plt.plot(targets[:, 1])
plt.title('Trajectory prediction of x2')
plt.figure()
_ = plt.plot(outputs[:, 2])
_ = plt.plot(targets[:, 2])
plt.title('Trajectory prediction of x3')
plt.figure()
_ = plt.plot(outputs[:, 3])
_ = plt.plot(targets[:, 3])
plt.title('Trajectory prediction of x4')
plt.show()
print('--- Finish ---')
def save_results(self, filename):
results_dict = self.runs[-1]
np.savez(filename, **results_dict)
# optimize weights
print("Initializing weights...")
init_weights = adam(init_gradient,
pre_init_weights,
step_size=0.1,
num_iters=INIT_ITERS,
callback=init_callback)
# pickle processed data in /cache (if doesn't already exist)
if not os.path.exists('cache'):
print('creating cache folder')
os.makedirs('cache')
if not os.path.isfile(picklefilename):
print('saving pickled regression initalization data')
np.savez(picklefilename, init_weights=init_weights)
###############################################################
###############################################################
# OPTIMIZE NOISE-AWARE LIKELIHOOD #
###############################################################
# Build noise-aware logistic regression objective.
accuracies, objective, gradient, unpack_params = build_noise_objective(
L2_VAR_2, NUM_TRAIN, train_images, train_labels, C, D, N, L)
# Build callback for ADAM optimizer
liklog = np.zeros(NUM_ITERATIONS)
param_log = np.zeros((NUM_ITERATIONS, N + L))
def callback(params, t, g):
lik = -objective(params, t)
NODAE_train_mean = np.array(stats_NODAE['train_loss'])[:, 0]
NODAE_train_std = np.array(stats_NODAE['train_loss'])[:, 1]
hnn_test_mean = np.array(stats_hnn['test_loss'])[:, 0]
hnn_test_std = np.array(stats_hnn['test_loss'])[:, 1]
NODAE_test_mean = np.array(stats_NODAE['test_loss'])[:, 0]
NODAE_test_std = np.array(stats_NODAE['test_loss'])[:, 1]
stats_hnn = [hnn_train_mean, hnn_train_std, hnn_test_mean, hnn_test_std]
stats_NODAE = [NODAE_train_mean, NODAE_train_std, NODAE_test_mean, NODAE_test_std]
return stats_hnn, stats_NODAE
if __name__ == "__main__":
args = get_args()
plt.rcParams.update({'figure.autolayout': True})
plt.rc('font', size=14)
if args.retrain:
stats_hnn, stats_NODAE = train(args)
np.savez('results_' + str(args.hidden_dim) + '_' + str(args.total_steps) + '.npz',
stats_hnn=stats_hnn, stats_NODAE=stats_NODAE)
else:
try:
results = np.load('results_' + str(args.hidden_dim) + '_' + str(args.total_steps) + '.npz',
allow_pickle=True)
stats_hnn = results['stats_hnn']
stats_NODAE = results['stats_NODAE']
except:
stats_hnn, stats_NODAE = train(args)
np.savez('results_' + str(args.hidden_dim) + '_' + str(args.total_steps) + '.npz',
stats_hnn=stats_hnn, stats_NODAE=stats_NODAE)
plot_results(args, stats_hnn, stats_NODAE)
plt.ylabel("inferred state switch time")
plt.legend()
plt.axis("equal")
plt.tight_layout()
# print(np.sum(np.array(true_z_dir) == np.array(z_dir)))
# print(np.sum(np.array(true_z_dir) == np.array(z_dir_bbvi)))
# save simulated experiment
# comp_2D_vlem_bbvi
params_vlem = test_acc.params
params_lds = test_acc_lds.params
q_params_vlem = q_lem.params
q_params_lds = q_lds.params
np.savez("simexp_comp_vlem_bbvi_2Dacc.npz",
params_true=latent_acc.params,
params_vlem=params_vlem,
params_lds=params_lds,
q_params_vlem=q_params_vlem,
q_params_lds=q_params_lds,
elbos_vlem=q_elbos_lem_total,
elbos_lds=q_elbos_lds,
ys=ys,
xs=xs,
us=us,
zs=zs,
bin_size=bin_size,
transition_Rs=latent_acc.transitions.Rs,
init_params=init_params,
init_var=init_var)
def grad_loss(x):
grad_f = grad(loss)(x)
print('gradient evaluated at {}: {}'.format(x, np.linalg.norm(grad_f)))
traj.append(x)
grad_traj.append(grad_f)
return grad_f
result = minimize(
loss,
theta0,
jac=grad_loss,
method='L-BFGS-B',
#method='Newton-CG',
#hessp=hessian_vector_product(loss),
#callback=callback,
bounds=bounds,
options={
'disp': True,
'maxiter': 100
})
theta1 = result.x
np.save(minimized_theta_fname, theta1)
traj_fname = os.path.join(
data_path, 'elemental_types_l-bfgs_freesolv_{}_traj.npy'.format(name))
np.savez(traj_fname, traj=np.array(traj), grad_traj=np.array(grad_traj))
print('theta after initial minimization', theta1)
print('gradient norm after minimization = {}'.format(
np.linalg.norm(grad_log_prob(theta1))))
def make_model(model_name):
if model_name == "baseball":
# baseball model and data
lnpdf_named = baseball.lnpdf
lnpdf_flat = baseball.lnpdf_flat
lnpdft = lambda z, t: np.squeeze(lnpdf_flat(z, t))
lnpdf = lambda z: np.squeeze(lnpdf_flat(z, 0))
D = baseball.D
return lnpdf, D, None
elif model_name == "frisk":
lnpdf_tmp, unpack, D, sdf, pnames = frisk.make_model_funs(
precinct_type=1)
def lnpdf(th):
lnpdf.counter += len(np.atleast_2d(th))
return lnpdf_tmp(th)
lnpdf.counter = 0
return lnpdf, D, pnames
elif model_name == "planarRobot_2":
from experiments.lnpdfs.create_target_lnpfs import build_target_likelihood_planar_autograd
lnpdf = build_target_likelihood_planar_autograd(2)[0]
return lnpdf, 2, None
elif model_name == "planarRobot_3":
from experiments.lnpdfs.create_target_lnpfs import build_target_likelihood_planar_autograd
lnpdf = build_target_likelihood_planar_autograd(3)[0]
return lnpdf, 3, None
elif model_name == "planarRobot_10":
from experiments.lnpdfs.create_target_lnpfs import build_target_likelihood_planar_autograd
lnpdf = build_target_likelihood_planar_autograd(10)[0]
return lnpdf, 10, None
elif model_name == "planarRobot4p_10":
from experiments.lnpdfs.create_target_lnpfs import build_target_likelihood_planar_4p_autograd
lnpdf = build_target_likelihood_planar_4p_autograd(10)[0]
return lnpdf, 10, None
elif model_name == "GMM_20":
from experiments.lnpdfs.create_target_lnpfs import build_GMM_lnpdf_autograd
[lnpdf, true_means, true_covs] = build_GMM_lnpdf_autograd(20, 10)
np.savez(args.output + 'target_gmm.npz',
true_means=true_means,
true_covs=true_covs)
return lnpdf, 20, None
elif model_name == "GMM_2":
from experiments.lnpdfs.create_target_lnpfs import build_GMM_lnpdf_autograd
[lnpdf, true_means, true_covs] = build_GMM_lnpdf_autograd(2, 10)
np.savez(args.output + 'target_gmm.npz',
true_means=true_means,
true_covs=true_covs)
return lnpdf, 2, None
elif model_name == "german_credit":
from experiments.lnpdfs.create_target_lnpfs import build_german_credit_lnpdf
lnpdf = build_german_credit_lnpdf(with_autograd=True)
return lnpdf, 25, None
elif model_name == "breast_cancer":
from experiments.lnpdfs.create_target_lnpfs import build_breast_cancer_lnpdf
lnpdf = build_breast_cancer_lnpdf(with_autograd=True)
return lnpdf, 31, None
elif model_name == "iono":
from experiments.lnpdfs.create_target_lnpfs import build_GPR_iono_with_grad_lnpdf
lnpdf_grad = build_GPR_iono_with_grad_lnpdf(remove_autograd=True)
def lnpdf(theta):
theta = np.atleast_2d(theta)
lnpdf.counter += len(theta)
output = []
for t in theta:
output.append(lnpdf_grad(t)[0])
return np.array(output)
lnpdf.counter = 0
return lnpdf, 34, None
break_condition='percent')
lnpdf.counter = true_counter + lnpdf.counter / 2 # we don't count the evaluations by the progress callback
# after all components are added, tune the weights of each comp
comp_list = mog_bbvi.fit_mixture_weights(vbobj.comp_list,
vbobj.lnpdf,
num_iters=1000,
step_size=.25,
num_samps_per_component=10 *
D,
ax=None)
vbobj.comp_list = comp_list
timestamps.append(time())
samples = vbobj.sample(2000)
np.savez(os.path.join(args.output, "vboost_comp_%d.npz" % k), samples,
timestamps, lnpdf.counter)
# save output here
vb_outfile = os.path.join(args.output, "vboost_comp_%d.pkl" % k)
lam_list = [(p, c.lam) for p, c in vbobj.comp_list]
with open(vb_outfile, 'wb') as f:
pickle.dump(lam_list, f)
## save output here
#vb_outfile = os.path.join(args.output, "vboost.pkl")
#lam_list = [(p, c.lam) for p, c in vbobj.comp_list]
#with open(vb_outfile, 'wb') as f:
# pickle.dump(lam_list, f)
#############################################
# Nonparametric variational inference code #
# --- save posterior parameters #
# OptRes = minimize(fun=objective, x0=controls_init, args=(args,), method="trust-constr", jac=objective_grad,
# hessp=BFGS(), constraints=nonlinear_constraint, bounds=bounds,
# options={'maxiter':100, 'gtol':1e-2, 'xtol':1e-2, 'initial_barrier_parameter':1e-1,
# 'disp': True, 'verbose':3})
# OptRes = minimize(fun=objective, x0=controls_init, method="trust-constr",
# jac=objective_grad, hessp=objective_hess, bounds=bounds,
# options={'maxiter':20, 'gtol':1e-2, 'disp':True, 'verbose':3})
print("optimization result = ", OptRes)
print("state name = ", state_name)
# compute the optimal solution
controls_opt = unflatten(OptRes["x"])
solution_opt = RK2(model.seir, y0, t_total, parameters, controls_opt)
# compute the effective reproduction number
Rt_opt = model.reproduction(t_total, parameters, controls_opt, solution_opt)
# save data
today = simulation_first_confirmed + len(data_confirmed)
np.savez(savefilename, configurations=configurations, parameters=parameters,
simulation_first_confirmed=simulation_first_confirmed, today=today,
solution=solution, controls=controls, Rt=Rt,
solution_opt=solution_opt, controls_opt=controls_opt, Rt_opt=Rt_opt)
# print("# total infected = ", N_total - np.sum(solution_opt[ten_death_day+len(deaths), :number_group]),
# "# total death = ", np.sum(solution_opt[ten_death_day+len(deaths), 7 * number_group:8 * number_group]),
# "# hospitalized = ", np.sum(solution_opt[ten_death_day+len(deaths), 5 * number_group:6 * number_group]))
})
print("OptRes = ", OptRes)
# compute the optimal solution
controls_opt = misfit.unflatten(OptRes["x"])
solution_opt = RK2(misfit.seir, misfit.y0, misfit.t_total,
misfit.parameters, controls_opt)
parameters_opt = misfit.parameters
# save data
today = misfit.simulation_first_confirmed + len(misfit.data_confirmed)
np.savez(savefilename,
configurations=configurations,
parameters=misfit.parameters,
simulation_first_confirmed=misfit.simulation_first_confirmed,
today=today,
solution=solution,
controls=misfit.controls,
solution_opt=solution_opt,
controls_opt=controls_opt,
parameters_opt=parameters_opt)
# import matplotlib.pyplot as plt
# plt.figure()
# alpha = OptRes["x"]
# # alpha = (np.tanh(alpha)+1)/2
# plt.plot(alpha, '.-')
# plt.show()
# dimension = 101
# prior = BrownianMotion(dimension)
# noise = np.random.normal(0, 1, dimension)
