def sample_param_grid_mpi():
"""Samples k1, kinv, k2 over a lattice and records obj. fn. evaluations. A starting point for future analysis"""
# set up mpi
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
nprocs = comm.Get_size()
# set up base model
A0 = 1.0 # initial concentration of A
k1_true = 0.1
kinv_true = 1000.0
k2_true = 1000.0
eigval_plus_true = 0.5 * (-(kinv_true + k1_true + k2_true) + np.sqrt(
np.power(k1_true + kinv_true + k2_true, 2) - 4 * k1_true * k2_true))
dt = 0.5 / np.abs(eigval_plus_true)
# start at dt, end at 5*dt
ntimes = 5 # somewhat arbitrary
times = np.linspace(dt, 5 * dt, ntimes)
model = Rawlings_Model(times,
A0,
k1_true,
kinv_true,
k2_true,
using_sympy=False)
# plot analytical results vs. qssa
if rank == 0:
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(times, model.gen_timecourse(k1_true, kinv_true, k2_true))
ax.plot(
times,
A0 * (1 - np.exp(-k1_true * k2_true * times /
(kinv_true + k2_true))))
plt.show()
nks = 10000000
# k1 \in [10^{-4}, 10^{-1}], kinv, k2 \in [10^1, 10^4]
ks = np.power(
10,
np.random.uniform(size=(nks, 3)) * np.array((3, 3, 3)) - np.array(
(4, -1, -1)))
nks_per_proc = nks / nprocs + 1 # add one to avoid rounding errors
params_and_of_evals = np.empty((nks_per_proc, 4))
count = 0
for k in uf.parallelize_iterable(ks, rank, nprocs):
params_and_of_evals[count] = model.lsq_of(k[0], k[1],
k[2]), k[0], k[1], k[2]
count = count + 1
all_params_and_of_evals = comm.gather(params_and_of_evals[:count], root=0)
if rank == 0:
all_params_and_of_evals = np.concatenate(all_params_and_of_evals)
print all_params_and_of_evals.shape
all_params_and_of_evals.dump('./data/params-ofevals.pkl')
def mm_contour_grid_mpi():
"""Calculates three-dimensional contours in K/V/S_t space in parallel through mpi4py, distributing S_t values over different processes and saving the output in './data/of_evals.csv'"""
# # attempt to turn off error messages
# np.seterr(all='ignore')
# init MPI
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
nprocs = comm.Get_size()
# nks = 1000 # number of K vals to sample
# nvs = 1000 # number of S vals to sample
# nsts = 6 # number of S_t vals to sample
# npts_per_proc = nsts/nprocs # number of St values to distribute to each processor
# Ks = 2*np.logspace(-1, 3, nks) # k vals
# Vs = np.logspace(-1, 3, nvs) # v vals
# Sts = 2*np.logspace(-0.5, 0.5, nsts) # st vals
# npts_per_proc = 1
# nepsilons = 400
# nkappas = 400
# epsilons = np.logspace(-6, 0, nepsilons)
# kappas = np.logspace(-5, 4, nkappas)
# nks = 500 # number of K vals to sample
# nvs = 500 # number of S vals to sample
# npts_per_proc = 1 #nsts/nprocs # number of St values to distribute to each processor
# Ks = 2*np.logspace(-1, 3, nks) # k vals
# Vs = np.logspace(-1, 3, nvs) # v vals
# set up base system
params = OrderedDict((('K',2.0), ('V',1.0), ('St',2.0), ('epsilon',1e-3), ('kappa',10.0))) # from Antonios' writeup
true_params = np.array(params.values())
nparams = true_params.shape[0]
transform_id = 't2'
nstate_params = 100
ncontinuation_params = 100
nthird_params = 1*nprocs
# state_params = {'id':'St', 'data':np.linspace(1.9, 2.1, nstate_params)}#2*np.logspace(-1, 3, nstate_params)}
state_params = {'id':'V', 'data':np.logspace(-1, 3, ncontinuation_params)} #np.linspace(0.5, 3.5, nstate_params)}
third_params = {'id':'K', 'data':np.logspace(-1, 3, ncontinuation_params)} #np.linspace(0.5, 4.5, ncontinuation_params)}
continuation_params = {'id':'St', 'data':[2.0]}#np.linspace(2, 3, nthird_params)}
# set init concentrations
S0 = params['St']; C0 = 0.0; P0 = 0.0 # init concentrations
Cs0 = np.array((S0, C0, P0))
# set times at which to collect data
tscale = (params['St'] + params['K'])/params['V'] # timescale of slow evolution
npts = 20
times = tscale*np.linspace(1,npts,npts)/5.0
# use these params, concentrations and times to define the MM system
contour = 0.01 # f_avg_error below tol will be saved
MM_system = MMS.MM_Specialization(Cs0, times, true_params, transform_id, [state_params['id']], continuation_params['id'], contour)
# true_traj_squared_norm = np.power(np.linalg.norm(MM_system.gen_profile(Cs0, times, true_params)[:,2]), 2) # for recording relative as error, scale of_eval by this norm
# loop over all parameter combinations
st_slices = []
# suppress output to stdout in the inner loop, as it's always (hopefully) about lsoda's performance
# with stdout_redirected():
for third_param in uf.parallelize_iterable(third_params['data'], rank, nprocs):
MM_system.adjust_const_param(third_params['id'], third_param)
count = 0 # counter of number of parameter combinations that pass tolerance
kept_pts = np.empty((nstate_params*ncontinuation_params,4)) # storage for parameter combinations that pass obj. fn. tol.
for state_param in state_params['data']:
for continuation_param in continuation_params['data']:
try:
# record relative error
f_eval = MM_system.f_avg_error(np.array((state_param,)), continuation_param)
except CustomErrors.EvalError:
continue
else:
if f_eval < 0:
kept_pts[count] = (state_param, continuation_param, third_param, f_eval)
count = count + 1
kept_pts = kept_pts[:count]
if count > 0:
st_slices.append(kept_pts)
if len(st_slices) > 0:
st_slices = np.concatenate(st_slices)
print st_slices.shape
else:
print 'no slices dawg'
st_slices = 'None'
# gather all the points to root and save
# kept_pts = kept_pts[:count]
all_pts = comm.gather(st_slices, root=0)
if rank is 0:
while 'None' in all_pts:
all_pts.remove('None')
full_pts = np.concatenate(all_pts)
header = ','.join([key + "=" + str(val) for key, val in params.items()]) + ',Tested=' + state_params['id'] + continuation_params['id'] + third_params['id']
np.savetxt('./data/contours_' + state_params['id'] + '_' + continuation_params['id'] + '_' + third_params['id'] + '.csv', full_pts, delimiter=',', header=header, comments='')
plt.scatter(full_pts[:,0], full_pts[:,2])
plt.show()
def dmaps_two_important_one_sloppy():
"""Generate parameter combinations in which there are two important (alpha, lambda) and one sloppy (epsilon) parameter(s) and use DMAPS with a kernel that accounts for both parameter-space distance and distances in model output, with the aim to uncover the alpha and lambda parameters"""
if os.path.isfile('./data/a-lam-eps-of-params-new.pkl'):
# already have data saved, load and trim data to approx 5000 pts for DMAPS
params = np.load('./data/a-lam-eps-of-params.pkl')
trajs = np.load('./data/a-lam-eps-trajs.pkl')
tol = 2e-2
trajs = trajs[params[:,3] < tol]
params = params[params[:,3] < tol]
params = params[:,:3]
print 'Have', params.shape[0], 'pts in dataset'
data = zip(params, trajs)
# epsilons = np.logspace(-3, 1, 5)
# kernels = [DMAPS_Data_Kernel(epsilon) for epsilon in epsilons]
# dmaps.kernel_plot(kernels, epsilons, data)
epsilon = 1e-2 # from epsilon plot
kernel = DMAPS_Data_Kernel(epsilon)
k = 30
eigvals, eigvects = dmaps.embed_data_customkernel(data, k, kernel, symmetric=True)
eigvals.dump('./data/dmaps-data-kernel-eigvals.pkl')
eigvects.dump('./data/dmaps-data-kernel-eigvects.pkl')
for i in range(1,k):
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(np.log10(params[:,0]), np.log10(params[:,1]), np.log10(params[:,2]), c=eigvects[:,i])
plt.savefig('./figs/data-space-dmaps' + str(i) + '.png')
# plt.show()
else:
# need to generate dataset
# CREATE DATASET (no dataset exists):
# init MPI
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
nprocs = comm.Get_size()
# set up base system
# specify ode parameters
(a_true, b_true, lam_true, eps_true) = (0.1, 1.0, 0.1, 0.001)
params = np.array((a_true, b_true, lam_true, eps_true))
# create system with given params
z_system = ZM.Z_Model(params)
# set up integration times
t0 = 3*eps_true # 0
tfinal = 1/lam_true
dt = eps_true
ntimes = 50
times = np.linspace(t0, tfinal, ntimes)
# get true trajectory based on true initial conditions
x0_true = np.array((1, a_true))
x_true_traj = z_system.get_trajectory(x0_true, times)
# set up sampling grid and storage space for obj. fn. evals
# lam_max = 1.2
nsamples = 100
lam_samples = np.linspace(0.9*lam_true, 1.1*lam_true, nsamples)
a_samples = np.linspace(0.9*a_true, 1.1*a_true, nsamples)
epsmin = 1e-6
epsmax = 1e-1
eps_samples = np.logspace(np.log10(epsmin), np.log10(epsmax), nsamples)
# add noise to each individual parameter combination to create nice dataset
params_noise = np.empty((nsamples*nsamples*nsamples, 4))
params_noise[:,0] = 0.01*np.random.normal(loc=0, size=nsamples*nsamples*nsamples) # same noise for both lam and a
params_noise[:,1] = 0 # no noise in b
params_noise[:,2] = 0.01*np.random.normal(loc=0, size=nsamples*nsamples*nsamples)
params_noise[:,3] = 0.1*np.random.normal(loc=0, size=nsamples*nsamples*nsamples) # noise for eps must vary with scale
# eps_samples = np.logspace(-6, np.log10(epsmax), nsamples)
params = np.empty((nsamples*nsamples*nsamples, 4)) # space for obj. fn. evals
trajs = np.empty((nsamples*nsamples*nsamples, ntimes, 2))
count = 0
for lam in uf.parallelize_iterable(lam_samples, rank, nprocs):
for eps in eps_samples:
for a in a_samples:
new_params = np.array((a, b_true, lam, eps)) + params_noise[count]*np.array((1,1,1,eps))
z_system.change_parameters(new_params)
try:
x_sample_traj = z_system.get_trajectory(x0_true, times)
except CustomErrors.IntegrationError:
continue
else:
params[count] = (new_params[0], new_params[2], new_params[3], get_of(x_sample_traj, x_true_traj)) # a, lam, eps
trajs[count] = x_sample_traj
count = count + 1
params = params[:count]
all_params = comm.gather(params, root=0)
trajs = trajs[:count]
all_trajs = comm.gather(trajs, root=0)
if rank is 0:
all_params = np.concatenate(all_params)
all_params.dump('./data/a-lam-eps-of-params-new.pkl')
all_trajs = np.concatenate(all_trajs)
all_trajs.dump('./data/a-lam-eps-trajs-new.pkl')
print '******************************\nData saved in ./data/a-lam-eps-...\n******************************'
def check_transformed_params_contours():
"""Attempt to generate a contour plot in c1/c2 space using the transformed model. **Does not work, dmaps_transformed_params successfully performs a similar function**"""
# init MPI
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
nprocs = comm.Get_size()
# specify ode parameters
(a_true, b_true, c1_true, c2_true) = (0.1, 0.1, 0.1, 0.001)
params = np.array((a_true, b_true, c1_true, c2_true))
# create system with given params
lam_max = 1.2
epsmax = 1e-1
S = 5.0
z_system = ZMT.Z_Model_Transformed(params, lam_max, epsmax, S)
# set up integration times
lam_true = S*lam_max*(c1_true*c1_true+c2_true*c2_true+np.arctan(c2_true/c1_true)/(2*np.pi*S))
eps_true = epsmax*np.arctan(c2_true/c1_true)/(2*np.pi*S)
print 'lamtrue, epstrue:', lam_true, eps_true
t0 = 0
tfinal = 1/lam_true
dt = eps_true
times = np.arange(t0, tfinal, dt)
ntimes = times.shape[0]
# get true trajectory based on true initial conditions
x0_true = np.array((1, a_true))
x_true_traj = z_system.get_trajectory(x0_true, times)
# set up sampling grid and storage space for obj. fn. evals
nsamples = 100
# c1_samples = np.logspace(-3, 3, nsamples)
# c2_samples = np.logspace(-3, 3, nsamples)
c1_samples = np.linspace(-np.sqrt(1 + 1/S), np.sqrt(1 + 1/S), nsamples)
c2_samples = np.linspace(-np.sqrt(1 + 1/S), np.sqrt(1 + 1/S), nsamples)
data = np.empty((nsamples*nsamples, 3)) # space for obj. fn. evals
count = 0
for c1 in uf.parallelize_iterable(c1_samples, rank, nprocs):
for c2 in c2_samples:
z_system.change_transformed_parameters(np.array((a_true, b_true, c1, c2)))
try:
x_sample_traj = z_system.get_trajectory(x0_true, times)
except CustomErrors.IntegrationError:
continue
else:
data[count] = (c1, c2, get_of(x_sample_traj, x_true_traj))
count = count + 1
data = data[:count]
all_data = comm.gather(data, root=0)
if rank is 0:
all_data = np.concatenate(all_data)
print 'of min,max:', np.min(data[:,2]), np.max(data[:,2])
# plot output
fig = plt.figure()
ax = fig.add_subplot(111)
# ax.set_xscale('log')
# ax.set_yscale('log')
tol = 1e2
all_data = all_data[all_data[:,2] < tol]
ax.scatter(all_data[:,0], all_data[:,1], c=all_data[:,2], s=40, lw=0)
# ax.set_ylabel(r'$\lambda$')
# ax.set_xlabel(r'$\epsilon$')
ax.set_xlabel('c1')
ax.set_ylabel('c2')
plt.show()
def data_space_plot():
"""Creates three-dimensional dataspace plot, creating trajectories from different values of a and b (parameters could be changed), and then plots this three-dimensional figure and colors by both selected parameters. **Note: This function uses the quadratic functional form for the fast manifold, as opposed to the linear form used above**"""
# init MPI
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
nprocs = comm.Get_size()
params = np.array((0.1, 0.5, 1, 0.001)) # (a, b, lambda, epsilon)
(a_true, b_true, lam_true, eps_true) = (0.1, 0.5, 1, 1000)
# create system with given params
z_system = ZM.Z_Model(params)
# set up integration times
t0 = 1.5
tfinal = 5
ntimes = 3
times = np.linspace(t0, tfinal, ntimes)
x0_true = np.array((1, 0.1))
if rank is 0:
# get true trajectory based on true initial conditions
x0_true = np.array((1, 0.1))
x_true_traj = z_system.get_trajectory_quadratic(x0_true, times)
plt.plot(x_true_traj[:,0], x_true_traj[:,1], lw=5)
# x_true_traj2 = z_system.get_trajectory_quadratic(x0_true, np.linspace(0,50,50))
# plt.plot(np.linspace(0,50,50), x_true_traj2[:,1])
plt.show()
nsamples = 50
a_samples = np.linspace(-.2, .2, nsamples)
b_samples = np.linspace(-3, 3, nsamples)
data = np.empty((nsamples*nsamples, 5)) # space for obj. fn. evals
count = 0
for a in uf.parallelize_iterable(a_samples, rank, nprocs):
for b in b_samples:
z_system.change_parameters(np.array((a, b, lam_true, eps_true)))
try:
x_sample_traj = z_system.get_trajectory_quadratic(x0_true, times)
except CustomErrors.IntegrationError:
continue
else:
data[count,:3] = x_sample_traj[:,1]
data[count,3:] = (a, b)
count = count + 1
data = data[:count]
all_data = comm.gather(data, root=0)
if rank is 0:
all_data = np.concatenate(all_data)
# plot output
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
# ax.set_xscale('log')
# ax.set_yscale('log')
ax.scatter(np.log10(all_data[:,0]), np.log10(all_data[:,1]), np.log10(all_data[:,2]), c=all_data[:,3], lw=0)
# ax.set_ylabel(r'$\lambda$')
# ax.set_xlabel(r'$\epsilon$')
ax.set_xlabel(r'$log(y_1)$')
ax.set_ylabel(r'$log(y_2)$')
ax.set_zlabel(r'$log(y_3)$')
ax.set_title('colored by a')
plt.show()
# plot output
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
# ax.set_xscale('log')
# ax.set_yscale('log')
ax.scatter(np.log10(all_data[:,0]), np.log10(all_data[:,1]), np.log10(all_data[:,2]), c=all_data[:,4], lw=0)
# ax.set_ylabel(r'$\lambda$')
# ax.set_xlabel(r'$\epsilon$')
ax.set_xlabel(r'$log(y_1)$')
ax.set_ylabel(r'$log(y_2)$')
ax.set_zlabel(r'$log(y_3)$')
ax.set_title('colored by b')
plt.show()
def check_params():
"""Plots grid of parameters colored by objective function value"""
# init MPI
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
nprocs = comm.Get_size()
# specify ode parameters
(a_true, b_true, lam_true, eps_true) = (1.0, 0.01, 1.0, 0.001) #(0.1, 0.01, 0.1, 0.1)
params = np.array((a_true, b_true, lam_true, eps_true))
# create system with given params
z_system = ZM.Z_Model(params)
# set up integration times
t0 = 0
tfinal = 1/lam_true
dt = eps_true
times = np.arange(t0, tfinal, dt)
ntimes = times.shape[0]
# get true trajectory based on true initial conditions
x0_true = np.array((1, a_true))
x_true_traj = z_system.get_trajectory_quadratic(x0_true, times)
# set up sampling grid and storage space for obj. fn. evals
nsamples = 100
a_samples = np.logspace(-2, 1, nsamples)
lam_samples = np.logspace(-2, 1, nsamples)
# b_samples = np.logspace(-4, -1, nsamples)
# a_samples = np.linspace(-.2, .2, nsamples)
# b_samples = np.linspace(-3, 3, nsamples)
data = np.empty((nsamples*nsamples, 3)) # space for obj. fn. evals
count = 0
for a in uf.parallelize_iterable(a_samples, rank, nprocs):
for lam in lam_samples:
z_system.change_parameters(np.array((a, b_true, lam, eps_true)))
try:
x_sample_traj = z_system.get_trajectory_quadratic(x0_true, times)
except CustomErrors.IntegrationError:
continue
else:
data[count] = (a, lam, get_of(x_sample_traj, x_true_traj))
count = count + 1
data = data[:count]
all_data = comm.gather(data, root=0)
if rank is 0:
all_data = np.concatenate(all_data)
all_data.dump('./data/a-lam-of.pkl')
# plot output
fig = plt.figure()
ax = fig.add_subplot(111)
ax.set_xscale('log')
ax.set_yscale('log')
ax.scatter(all_data[:,0], all_data[:,1], c=np.log10(all_data[:,2]), s=40)
# ax.set_ylabel(r'$\lambda$')
# ax.set_xlabel(r'$\epsilon$')
ax.set_xlabel('a')
ax.set_ylabel('b')
plt.show()
def dmaps_transformed_params():
"""Perform DMAP on nonlinear, swirled transformation of parameters lambda/epsilon (important/sloppy)"""
if os.path.isfile('./data/a-lam-ofevals-2016.csv'): # os.path.isfile('./data/lam_eps_ofevals-2016.csv'):
# PERFORM THE DMAP (already generated pts):
print 'Already have sloppy data, transforming and embedding'
data = np.genfromtxt('./data/a-lam-ofevals-2016.csv', delimiter=',')
# extract sloppy parameter combinations
tol = 50 # 0.01
data = data[data[:,-1] < tol]
# transform into swirl in c1/c2
S = 1.0 # for now we require S <= 1 to invert back to lambda/epsilon
# questionable redefinition of max param values
lam_max, epsmax = np.max(data[:,:2], axis=0)
# c1 = lambda l, e: np.sqrt(e/epsmax + l/(S*lam_max))*np.cos(2*np.pi*S*e/epsmax)
# c2 = lambda l, e: np.sqrt(e/epsmax + l/(S*lam_max))*np.sin(2*np.pi*S*e/epsmax)
y1 = lambda l, e: l + np.power(np.log10(e)- np.average(np.log10(e)), 2)
y2 = lambda l, e: np.log10(e) - np.average(np.log10(e))
a = 1.3
b = 0.3
# do the actual transformation
cs1 = np.array(henon(data[:,1], data[:,0], 1, a, b)).T
cs2 = np.array(henon(data[:,1], data[:,0], 2, a, b)).T
cs3 = np.array(henon(data[:,1], data[:,0], 3, a, b)).T
cs4 = np.array(henon(data[:,1], data[:,0], 4, a, b)).T
# look at dataset and subsequent transformations
fig = plt.figure()
ax = fig.add_subplot(111)
ax.scatter(data[:,1], data[:,0], c=data[:,2], s=3)
ax.set_xlabel(r'$x_0 (= \lambda)$', fontsize=72)
ax.set_ylabel(r'$y_0 (= a)$', fontsize=72)
fig.subplots_adjust(bottom=0.15)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.scatter(cs1[:,0], cs1[:,1], c=data[:,2], s=3)
ax.set_xlabel(r'$x_1$', fontsize=72)
ax.set_ylabel(r'$y_1$', fontsize=72)
fig.subplots_adjust(bottom=0.15)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.scatter(cs2[:,0], cs2[:,1], c=data[:,2], s=3)
ax.set_xlabel(r'$x_2$', fontsize=72)
ax.set_ylabel(r'$y_2$', fontsize=72)
fig.subplots_adjust(bottom=0.15)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.scatter(cs3[:,0], cs3[:,1], c=data[:,2], s=3)
ax.set_xlabel(r'$x_3$', fontsize=72)
ax.set_ylabel(r'$y_3$', fontsize=72)
fig.subplots_adjust(bottom=0.15)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.scatter(cs4[:,0], cs4[:,1], c=data[:,2], s=3)
ax.set_xlabel(r'$x_4$', fontsize=72)
ax.set_ylabel(r'$y_4$', fontsize=72)
fig.subplots_adjust(bottom=0.15)
plt.show()
# neps = 8
# eps = np.logspace(-3, 3, neps)
# epsilon_plot(eps, cs)
eps = 1e-1
eigvals, eigvects = dmaps.embed_data(cs2, k=12, epsilon=eps)
plot_dmaps.plot_xy(cs2[:,0], cs2[:,1], color=eigvects[:,1], scatter=True, xlabel=r'$y_1$', ylabel=r'$y_2$')
# plot_dmaps.plot_embeddings(eigvects, eigvals, k=4)
else:
# CREATE DATASET (no dataset exists):
# init MPI
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
nprocs = comm.Get_size()
# set up base system
# specify ode parameters
(a_true, b_true, lam_true, eps_true) = (1.0, 0.01, 1.0, 0.001) # (0.1, 0.01, 0.1, 0.001)
params = np.array((a_true, b_true, lam_true, eps_true))
# create system with given params
z_system = ZM.Z_Model(params)
# set up integration times
t0 = 0
tfinal = 1.0/lam_true
dt = eps_true
times = np.arange(t0, tfinal, dt)
ntimes = times.shape[0]
# get true trajectory based on true initial conditions
x0_true = np.array((1, a_true))
x_true_traj = z_system.get_trajectory_quadratic(x0_true, times)
# # set up sampling grid and storage space for obj. fn. evals
# lam_max = 1.2
# epsmax = 1e-1
# nsamples = 500
# lam_samples = np.linspace(0.9*lam_true, 1.1*lam_true, nsamples)
# eps_samples = np.linspace(0, epsmax, nsamples)
# eps_samples = np.logspace(-6, np.log10(epsmax), nsamples)
# data = np.empty((nsamples*nsamples, 3)) # space for obj. fn. evals
nsamples = 40000
data = np.empty((nsamples, 3))
a_lam_samples = np.random.uniform(size=(nsamples, 2))*np.array((1.5,1.5)) + np.array((0.25, 0.25)) # a \in (7, 9) lamb \in (6, 11)
count = 0
for a, lam in uf.parallelize_iterable(a_lam_samples, rank, nprocs):
z_system.change_parameters(np.array((a, b_true, lam, eps_true)))
try:
x_sample_traj = z_system.get_trajectory_quadratic(x0_true, times)
except CustomErrors.IntegrationError:
continue
else:
data[count] = (a, lam, get_of(x_sample_traj, x_true_traj))
count = count + 1
# count = 0
# for eps in eps_samples:
# z_system.change_parameters(np.array((a_true, b_true, lam, eps)))
# try:
# x_sample_traj = z_system.get_trajectory(x0_true, times)
# except CustomErrors.IntegrationError:
# continue
# else:
# data[count] = (lam, eps, get_of(x_sample_traj, x_true_traj))
# count = count + 1
data = data[:count]
all_data = comm.gather(data, root=0)
if rank is 0:
all_data = np.concatenate(all_data)
np.savetxt('./data/a-lam-ofevals-2016.csv', all_data, delimiter=',')
print '******************************\n \