def sobol_test_generate():
"""
sobol_test02 tests i4_sobol_generate.
"""
print("\nSOBOL_TEST_GENERATE" " I4_BIT_ returns the location of the high 1 bit." "\n I I4_BIT_HI1(I)\n")
target = np.array(
[
[0.5, 0.5, 0.5, 0.5, 0.5],
[0.75, 0.25, 0.75, 0.25, 0.75],
[0.25, 0.75, 0.25, 0.75, 0.25],
[0.375, 0.375, 0.625, 0.125, 0.875],
[0.875, 0.875, 0.125, 0.625, 0.375],
[0.625, 0.125, 0.375, 0.375, 0.125],
[0.125, 0.625, 0.875, 0.875, 0.625],
[0.1875, 0.3125, 0.3125, 0.6875, 0.5625],
[0.6875, 0.8125, 0.8125, 0.1875, 0.0625],
[0.9375, 0.0625, 0.5625, 0.9375, 0.3125],
]
)
results = i4_sobol_generate(5, 10)
assert np.all(target == results), "Array values not as expected"
return
def sample(self, num, d=None, rng=np.random):
if d is None or d < 1 or d > 40: # TODO: also check if integer
raise ValueError("d (%d) must be integer in range [1, 40]" % d)
num, d = self._sample_shape(num, d)
#from scipy.stats import uniform
#mdd = MultiDimDistribution([uniform for _ in range(d)])
#return np.asarray(mdd.sobol(num))
return i4_sobol_generate(d, num, skip=0)
def getSobolCosinePointsH2(n):
sobolpoints = sobol_seq.i4_sobol_generate(2, n)
#map to hemisphere cosine weighted
sobolpoints[:, 0] = np.arcsin(np.sqrt(sobolpoints[:,0]))
sobolpoints[:, 1] = sobolpoints[:, 1] * 2 * np.pi
return sobolpoints
def getSobolSequencePointsH2(n):
sobolpoints = sobol_seq.i4_sobol_generate(2, n)
sobolpoints[:, 1] = sobolpoints[:, 1] * 2 * np.pi
#map to hemisphere
sobolpoints[:, 0] = np.arccos(sobolpoints[:,0])
return sobolpoints
def get_samples(self, init_points_count):
samples = np.empty((init_points_count, self.space.dimensionality))
# Use random design to fill non-continuous variables
random_design = RandomDesign(self.space)
random_design.fill_noncontinous_variables(samples)
if self.space.has_continuous():
bounds = self.space.get_continuous_bounds()
lower_bound = np.asarray(bounds)[:,0].reshape(1,len(bounds))
upper_bound = np.asarray(bounds)[:,1].reshape(1,len(bounds))
diff = upper_bound-lower_bound
from sobol_seq import i4_sobol_generate
X_design = np.dot(i4_sobol_generate(len(self.space.get_continuous_bounds()),init_points_count),np.diag(diff.flatten()))[None,:] + lower_bound
samples[:, self.space.get_continuous_dims()] = X_design
return samples
def acq_max_geometric(ac, gp, bounds,cache_sobol):
"""
A function to find the maximum of the acquisition function using
the scipy python
Input Parameters
----------
ac: The acquisition function object that return its point-wise value.
gp: A gaussian process fitted to the relevant data.
y_max: The current maximum known value of the target function.
bounds: The variables bounds to limit the search of the acq max.
Returns
-------
x_max, The arg max of the acquisition function.
"""
dim=bounds.shape[0]
# Start with the lower bound as the argmax
x_max = bounds[:, 0]
max_acq = None
#myopts ={'maxiter':5*dim,'maxfun':10*dim}
#myopts ={'maxiter':5*dim}
# create a grid
#XXX = np.meshgrid(*[np.linspace(i,j,10)[:-1] for i,j in zip(bounds[:,0],bounds[:,1])])
ninitpoint=200*dim
#ninitpoint=5*dim
if cache_sobol is not None:
x_tries=cache_sobol
else:
print('sobol sequence is not cached')
x_tries = sobol_seq.i4_sobol_generate(dim, ninitpoint)
# randomly select points and evaluate points from a grid
# Find the minimum of minus the acquisition function
#x_tries = np.random.uniform(bounds[:, 0], bounds[:, 1],size=(20*dim, dim))
# evaluate
#start_eval=time.time()
y_tries=ac(x_tries,gp=gp)
#end_eval=time.time()
#print "elapse evaluate={:.5f}".format(end_eval-start_eval)
#find x optimal for init
idx_max=np.argmax(y_tries)
x_max=x_tries[idx_max]
#start_opt=time.time()
#res = minimize(lambda x: -ac(x.reshape(1, -1), gp=gp),x_init_max.reshape(1, -1),bounds=bounds,method="L-BFGS-B",options=myopts)#L-BFGS-B
#res = fmin_bfgs(lambda x: -ac(x.reshape(1, -1), gp=gp, y_max=y_max),x_init_max.reshape(1, -1),disp=False)#L-BFGS-B
# value at the estimated point
#val=ac(res.x,gp,y_max)
# Clip output to make sure it lies within the bounds. Due to floating
# point technicalities this is not always the case.
#return np.clip(x_max[0], bounds[:, 0], bounds[:, 1])
return np.clip(x_max, bounds[:, 0], bounds[:, 1])
def generate_pos_3d(lcurve, rcurve, target_area, ly, ry, n, seed):
nl = ly.size - 1
nr = ry.size - 1
assert (len(lcurve) == nl)
assert (len(rcurve) == nr)
if min(ly) != min(ry):
print(f'{ly}:{ry}')
assert (min(ly) == min(ry))
if max(ly) != max(ry):
print(f'{ly}:{ry}')
assert (max(ly) == max(ry))
def collect_3d(n, x, y, z):
selected = np.ones(n, dtype=bool)
for i in range(n):
for j in range(nl):
if ly[j] < y[i] and y[i] < ly[j + 1]:
if lcurve[j].check(y[i]) > x[i]:
selected[i] = False
break
if selected[i]:
for j in range(nr):
if ry[j] < y[i] and y[i] < ry[j + 1]:
if rcurve[j].check(y[i]) < x[i]:
selected[i] = False
break
pos = np.array([x[selected], y[selected], z[selected]])
return pos, sum(selected)
xmax = max([r.xmax() for r in rcurve])
xmin = min([l.xmin() for l in lcurve])
ymax = max(ly)
ymin = min(ly)
storming_area = (xmax - xmin) * (ymax - ymin)
assert (storming_area > 0)
#print(xmax,xmin,ymax,ymin, storming_area)
ratio = storming_area / target_area
#print(ratio)
# to do: if ratio > some threshold rotate the coordinates and implement methods for the corresponding change for the Class of curves, too
ntmp = np.ceil(n * ratio).astype(int)
i = 0
pos = np.empty((3, n), dtype=float)
skip = 602
#qrng = rand.QRNG(rndtype=rand.QRNG.SCRAMBLED_SOBOL32, ndim=2)
count = 0
while (i < n):
#irands = np.empty((2,ntmp), dtype='uint32')
rands = ss.i4_sobol_generate(3, ntmp, skip=skip)
# wait for scipy 1.7.0
x = xmin + (xmax - xmin) * rands[:, 0]
y = ymin + (ymax - ymin) * rands[:, 1]
z = 0.01 * rands[:, 2]
acquired_pos, nselected = collect_3d(ntmp, x, y, z)
if i + nselected > n:
nselected = n - i
pos[:, i:i + nselected] = acquired_pos[:, :nselected]
i += nselected
ntmp = np.ceil((n - i) * ratio).astype(int)
skip = skip + ntmp
count += 1
if count > 10:
print(count, ntmp)
return pos
plt.scatter(x2k, y2k, s=1, marker='.')
plt.yticks([])
plt.xticks([])
plt.subplot(2, 5, 5)
x5k = [random.uniform(0, 4) for x in range(5000)]
y5k = [random.uniform(0, 4) for x in range(5000)]
plt.title("N=5000")
plt.scatter(x5k, y5k, s=1, marker='.')
plt.yticks([])
plt.xticks([])
#Quasi-Random goes down here. Fingers crossed.
plt.subplot(2, 5, 6)
sobol_100_x = sobol_seq.i4_sobol_generate(4, 100)
x100 = sobol_100_x[:, 0]
y100 = sobol_100_x[:, 1]
plt.ylabel("Quasi Random")
plt.scatter(x100, y100, s=1, marker='.')
plt.yticks([])
plt.xticks([])
plt.subplot(2, 5, 7)
sobol_500_x = sobol_seq.i4_sobol_generate(4, 500)
x500 = sobol_500_x[:, 0]
y500 = sobol_500_x[:, 1]
plt.scatter(x500, y500, s=1, marker='.')
plt.yticks([])
plt.xticks([])
def generate_initial_observations(n,
logger,
loaded_init_theta=None,
loaded_init_G=None,
loaded_init_G_sem=None):
"""
Takes an integer `n` and generates `n` initial observations
from the black box function using Sobol random parameter settings
in the unit cube. Returns parameter setting and black box function outputs.
If `loaded_init_theta/G/G_sem` are specified, initialization is loaded (possibly partially, in which
case the initialization using the Sobol random sequence is continued where left off).
"""
if n <= 0:
raise ValueError(
'qKnowledgeGradient and GP needs at least one observation to be defined properly.'
)
# sobol sequence proposal points
# new_thetas: [n, n_params]
new_thetas = torch.tensor(sobol_seq.i4_sobol_generate(n_params, n),
dtype=torch.float)
# check whether initial observations are loaded
loaded = (loaded_init_theta is not None and loaded_init_G is not None
and loaded_init_G_sem is not None)
if loaded:
n_loaded = loaded_init_theta.shape[
0] # loaded no. of observations total
n_loaded_init = min(
n_loaded,
n) # loaded no. of quasi-random initialization observations
n_init = max(
n_loaded, n
) # final no. of observations returned, at least quasi-random initializations
# check whether loaded proposal points are same as without loading observations
try:
assert (np.allclose(loaded_init_theta[:n_loaded_init],
new_thetas[:n_loaded_init]))
except AssertionError:
print(
'\n\n\n===> Warning: parameters of loaded inital observations '
'do not coincide with initialization that would have been done. '
'Double check simulation, ninit, and parameter bounds, which could change '
'the initial random Sobol sequence. \nThe loaded parameter settings are used. \n\n\n'
)
if n_init > n:
new_thetas = loaded_init_theta # size of tensor increased to `n_init`, as more than Sobol init points loaded
else:
n_loaded = 0 # loaded no. of observations total
n_loaded_init = 0 # loaded no. of quasi-random initialization observations
n_init = n # final no. of observations returned, at least quasi-random initializations
# instantiate simulator observation tensors
if per_age_group_objective:
# new_G, new_G_sem: [n_init, n_days * n_age] (flattened outputs)
new_G = torch.zeros((n_init, n_days * n_age), dtype=torch.float)
new_G_sem = torch.zeros((n_init, n_days * n_age),
dtype=torch.float)
else:
# new_G, new_G_sem: [n_init, n_days]
new_G = torch.zeros((n_init, n_days), dtype=torch.float)
new_G_sem = torch.zeros((n_init, n_days), dtype=torch.float)
# generate `n` initial evaluations at quasi random settings; if applicable, skip and load expensive evaluation result
for i in range(n_init):
# if loaded, use initial observation for this parameter settings
if loaded and i <= n_loaded - 1:
new_thetas[i] = loaded_init_theta[i]
G, G_sem = loaded_init_G[i], loaded_init_G_sem[i]
walltime = 0.0
# if not loaded, evaluate as usual
else:
t0 = time.time()
G, G_sem = composite_simulation(new_thetas[i])
walltime = time.time() - t0
new_G[i] = G
new_G_sem[i] = G_sem
# log
G_objectives = objective(new_G[:i + 1])
best_idx = G_objectives.argmax()
best = G_objectives[best_idx].item()
current = objective(G).item()
if per_age_group_objective:
case_diff = G.reshape(n_days,
n_age)[-1].sum() - G_obs_aggregate[-1]
else:
case_diff = G[-1] - G_obs_aggregate[-1]
logger.log(i=i - n,
time=walltime,
best=best,
objective=current,
case_diff=case_diff,
theta=transforms.unnormalize(
new_thetas[i, :].detach().squeeze(), sim_bounds))
# save state
state = {
'train_theta': new_thetas[:i + 1],
'train_G': new_G[:i + 1],
'train_G_sem': new_G_sem[:i + 1],
'best_observed_obj': best,
'best_observed_idx': best_idx,
}
save_state(state, logger.filename)
# compute best objective from simulations
f = objective(new_G)
best_f_idx = f.argmax()
best_f = f[best_f_idx].item()
return new_thetas, new_G, new_G_sem, best_f, best_f_idx
def non_uniform_grid(num, ndim, skip=42, large=False):
"""Build a non-uniform grid with num points of ndim dimensions."""
if not large:
_check_not_too_large(num * ndim)
return sobol_seq.i4_sobol_generate(ndim, num, skip=skip)
particles[:, 0] = particles[:, 0] * Lz
particles[:, 1] = sp.erfinv(2 * particles[:, 1] - 1) * wperp * np.sqrt(2)
particles[:, 2] = sp.erfinv(2 * particles[:, 2] - 1) * wperp * np.sqrt(2)
particles[:, 3] = sp.erfinv(2 * particles[:, 3] - 1) * wpar * np.sqrt(2)
elif loading == 'external loading':
particles[:, :] = np.load(name_initial_particles)
# inversion of cumulative distribution function
particles[:, 0] = particles[:, 0] * Lz
particles[:, 1] = sp.erfinv(2 * particles[:, 1] - 1) * wperp * np.sqrt(2)
particles[:, 2] = sp.erfinv(2 * particles[:, 2] - 1) * wperp * np.sqrt(2)
particles[:, 3] = sp.erfinv(2 * particles[:, 3] - 1) * wpar * np.sqrt(2)
elif loading == 'sobol_plain':
particles[:, :4] = sobol.i4_sobol_generate(4, Np, 1000)
# inversion of cumulative distribution function
particles[:, 0] = particles[:, 0] * Lz
particles[:, 1] = sp.erfinv(2 * particles[:, 1] - 1) * wperp * np.sqrt(2)
particles[:, 2] = sp.erfinv(2 * particles[:, 2] - 1) * wperp * np.sqrt(2)
particles[:, 3] = sp.erfinv(2 * particles[:, 3] - 1) * wpar * np.sqrt(2)
elif loading == 'sobol_antithetic16':
pic.set_particles_symmetric(sobol.i4_sobol_generate(4, int(Np / 16), 1000),
particles)
# inversion of cumulative distribution function
particles[:, 0] = particles[:, 0] * Lz
particles[:, 1] = sp.erfinv(2 * particles[:, 1] - 1) * wperp * np.sqrt(2)
particles[:, 2] = sp.erfinv(2 * particles[:, 2] - 1) * wperp * np.sqrt(2)
x = [random.random() for k in range(N[i])]
y = [random.random() for k in range(N[i])]
axes = plt.subplot(2, 5, i + 1)
plt.xlim(0.0, 1.0)
plt.ylim(0.0, 1.0)
axes.set_title('N=' + str(N[i]))
axes.set_aspect('equal')
plt.scatter(x, y, s=1)
if i == 0:
axes.set_ylabel('Pseudo-Random', rotation=90, size='large')
else:
axes.get_yaxis().set_ticklabels([])
axes.get_xaxis().set_ticklabels([])
for i in range(len(N)):
z = sobol_seq.i4_sobol_generate(2, N[i])
x = z[:, 0]
y = z[:, 1]
axes = plt.subplot(2, 5, i + len(N) + 1)
plt.xlim(0.0, 1.0)
plt.ylim(0.0, 1.0)
axes.set_aspect('equal')
plt.scatter(x, y, s=1)
if i == 0:
axes.set_ylabel('Quasi-Random', rotation=90, size='large')
else:
axes.get_yaxis().set_ticklabels([])
fig.tight_layout()
plt.subplots_adjust(wspace=0.1, hspace=0.1)
plt.show()
def _generate_doe_design(self):
"""
This function is responsible for generating the matrix of operating
conditions used in the design of experiments. It supports all of the
design types implemented by pyDOE with the exception of general full
factorials (including mixed level factorials). Full factorials are only
permitted to have two levels at the moment.
Parameters
----------
None
Returns
-------
None, but updates the self object to have the needed auxiliary data
"""
# Unpack the dictionary of DOE design parameters
doe_type = self.doe_design['doe_args']['type']
kwargs = self.doe_design['doe_args']['args']
# Get the list of parameters to iterate over
try:
param_list = self.doe_design['doe_params']
except:
self._generate_doe_param_list()
param_list = self.doe_design['doe_params']
n = len(param_list)
# Create the design matrix in coded units
if doe_type == 'full2': # Two level general factorial
coded_design_matrix = pyDOE.ff2n(n)
elif doe_type == 'frac': # Fractional factorial
gen = kwargs.pop('gen', None)
if gen is None:
raise ValueError(
'No generator sequence specified for a fractional factorial design.'
)
coded_design_matrix = pyDOE.fracfact(gen)
elif doe_type == 'pb': # Plackett-Burman
coded_design_matrix = pyDOE.pbdesign(n)
elif doe_type == 'bb': # Box-Behnken
coded_design_matrix = pyDOE.bbdesign(n, **kwargs)
elif doe_type == 'cc': # Central composite
coded_design_matrix = pyDOE.ccdesign(n, **kwargs)
elif doe_type == 'lh': # Latin hypercube
coded_design_matrix = pyDOE.lhs(n, **kwargs)
elif doe_type == 'sob': # Sobol' Lp-tau low discrepancy sequence
samples = kwargs.pop('samples')
coded_design_matrix = sobol_seq.i4_sobol_generate(n, samples)
else:
raise ValueError('Unrecognized DOE design option ' + doe_type)
# Convert the coded design matrix into an uncoded design matrix (i.e.,
# in terms of the raw operating conditions). This takes the minimum and
# maximum values from the distributions and places the points
# accordingly.
a_array = np.zeros(n) # Minimum
b_array = np.zeros(n) # Maximum
for i in range(n):
pkey = param_list[i]
a_array[i] = self.doe_design['doe_param_dist'][pkey].a
b_array[i] = self.doe_design['doe_param_dist'][pkey].b
r_array = b_array - a_array # Ranges for each dimension
if doe_type in ['pb', 'bb', 'cc', 'frac', 'full2']:
# These designs all have points clustered around a distinct center.
# The coded matrix is in terms of unit perturbations from the
# center, so we can just scale them by the ranges before adding the
# center value. For these designs, we actually want to use half the
# range so that the points that are supposed to be at the min/max
# values end up there.
c_array = (a_array + b_array) / 2 # Center is average of min, max
doe_op_conds = coded_design_matrix * r_array / 2 + c_array
elif doe_type in ['lh', 'sob']:
# The Latin hypercube and Sobol' sequences space points between a
# range. This means the coded design matrix has all elements on
# (0, 1). Since we don't have a center point, we place the operating
# conditions with respect to the minimum values.
doe_op_conds = coded_design_matrix * r_array + a_array
self.doe_design['doe_op_conds'] = doe_op_conds
def traj_segment_generator(pi, env, horizon, stochastic, num_options, saves,
results, rewbuffer, dc):
max_action = env.action_space.high
t = 0
glob_count = 0
glob_count_thresh = -1
ac = env.action_space.sample() # not used, just so we have the datatype
new = True # marks if we're on first timestep of an episode
ob = env.reset()
ob_env_shape = np.shape(ob)
ac_env_shape = np.shape(ac)
ac = pi.reset_last_act().eval()
ob = np.concatenate((ob, ac))
cur_ep_ret = 0 # return in current episode
cur_ep_len = 0 # len of current episode
ep_rets = [] # returns of completed episodes in this segment
ep_lens = [] # lengths of ...
# Initialize history arrays
horizon = 500
obs = np.array([ob for _ in range(horizon)])
rews = np.zeros(horizon, 'float32')
realrews = np.zeros(horizon, 'float32')
vpreds = np.zeros(horizon, 'float32')
wrong_checks = np.zeros(1, 'int32')
news = np.zeros(horizon, 'int32')
opts = np.zeros(horizon, 'int32')
incorrect = np.zeros(horizon, 'int32')
opts_val = np.zeros(horizon, 'float32')
acs = np.array([ac for _ in range(horizon)])
prevacs = acs.copy()
# These are params that need to be predefined!
# load the previously exported file:
nnet_file_name = 'standart_all_comp.nnet'
# define the angular range and the safe angular range
#for the retraining if a point is unstable it has to be in the safe range
ang = 1 * 2.5 * 0.0174533
ang_save = ang - 0.0001
# define the angular velocity and the safe angular velocity range
angvel = 1 * 5.0 * 0.0174533
angvel_save = angvel - 0.0001
while True:
if (t > 0):
yield {
"ob": obs,
"rew": rews,
"realrew": realrews,
"vpred": vpreds,
"new": news,
"ac": acs,
"opts": opts,
"opts_val": opts_val,
"incorrect": incorrect,
"wrong_checks": wrong_checks
}
t = 0
# first do the overall check:
unsucess = check_whole(nnet_file_name, ang, ang_save, angvel,
angvel_save)
if (True):
if (len(unsucess) == 0):
print("YES WE DID IT -> CONVERGENCE WAS REACHED!")
wrong_checks[0] = 0
else:
wrong_checks[0] = len(unsucess)
for i in range(len(unsucess)):
obs[t] = [
unsucess[i][0], unsucess[i][1], unsucess[i][2],
unsucess[i][4]
]
acs[t] = unsucess[i][3]
incorrect[t] = 1
opts_val[t] = -2.0
opts[t] = 1
t += 1
sample = None
num_local_samples = 0 #
# generate additional points using Sobol sequences
size_to_gen = (horizon - (num_local_samples + 1) * len(unsucess))
if (True):
# using sobol
sample_new = np.zeros((size_to_gen, 4))
sample_new[:, 1:4] = (
(sobol_seq.i4_sobol_generate(3, size_to_gen)) * 2 - 1).reshape(
size_to_gen, 3)
sample_new[:, 0] = 1.0
sample_new[:, 1] = sample_new[:, 1] * ang
sample_new[:, 2] = sample_new[:, 2] * angvel
if (sample is None):
sample = sample_new
else:
sample = np.concatenate((sample, sample_new))
overall_things = 0
curr_correct = 0
comm_savings = 0
no_comm_samples = 0
# now assign the correct values to the points:
for i in range((np.shape(sample))[0]):
overall_things += 1
dec = pi._get_op_orig([sample[i]])[0][0][0]
if (dec > 0): #this means we select opt 0:
curr_opt = 0
comm_savings += 1
else:
curr_opt = 1
# check the individual points:
corr, point = check_whole_comp_comm_eff(nnet_file_name,
sample[i, 1], ang_save,
sample[i, 2], angvel_save,
sample[i, 3], curr_opt)
if (corr):
if (point == "no_comm_also_works"):
# special case: saving communication also works -> we want this label
obs[t] = [
sample[i, 0], sample[i, 1], sample[i, 2], sample[i, 3]
]
acs[t] = sample[i, 3]
incorrect[t] = 1
opts_val[t] = 0.4
opts[t] = 0
no_comm_samples += 1
else:
curr_correct += 1
obs[t] = [
sample[i, 0], sample[i, 1], sample[i, 2], sample[i, 3]
]
acs[t] = sample[i, 3]
incorrect[t] = 0
if (dec > 0):
# this means we skip communication:
opts_val[t] = 0.4
no_comm_samples += 1
opts[t] = 0
else:
# for case of communication assign value of -2
# -> this case is more important compared to saving communication,...
opts_val[t] = -2.0
opts[t] = 1
else:
# the point is incorrect -> also give -2 but additionally mark as incorrect
obs[t] = [
sample[i, 0], sample[i, 1], sample[i, 2], sample[i, 3]
]
acs[t] = point[3]
incorrect[t] = 1
opts_val[t] = -2.0
opts[t] = 1
t += 1
print("Rate correct samples: " + str(curr_correct / overall_things))
print("Comm savings: " + str(comm_savings / overall_things))
print(no_comm_samples)
time.sleep(5.0)
"""Part 3.2""" plt.subplot(2, 5, 1) N = 100 x = np.random.rand(N) y = np.random.rand(N) plt.scatter(x, y) plt.subplot(2, 5, 6) vals = sobol_seq.i4_sobol_generate(2, 100) vals[:,0] vals[:,1] plt.scatter(x=vals[:,0], y=vals[:,1]) plt.subplot(2, 5, 2) N = 500 x = np.random.rand(N) y = np.random.rand(N) plt.scatter(x, y) plt.subplot(2, 5, 7) vals = sobol_seq.i4_sobol_generate(2, 500) vals[:,0] vals[:,1] plt.scatter(x=vals[:,0], y=vals[:,1])
def __init__(self, p, kind="random", grid_source="mat"):
m = p.grid_size
σ = np.array([p.σηR, p.σηa, p.σηL, p.σηu, p.σηB, p.σηG])
ρ = np.array([p.ρηR, p.ρηa, p.ρηL, p.ρηu, p.ρηB, p.ρηG])
if kind == "sobol":
if grid_source == "mat":
_path = os.path.join(DIR, "Sobol_grids.mat")
s = loadmat(_path)["Sobol_grids"][:m, :]
else:
s = sobol_seq.i4_sobol_generate(8, m)
sη = s[:, :6]
η = (-2*σ + 4*(sη.max(0)-sη) / (sη.max(0)-sη.min(0))*σ)/np.sqrt(1-ρ**2)
R = 1+0.05*(np.max(s[:, 6])-s[:, 6])/(np.max(s[:, 6])-np.min(s[:, 6]))
δ = 0.95+0.05*(np.max(s[:, 7])-s[:, 7])/(np.max(s[:, 7])-np.min(s[:, 7]))
else:
# Values of exogenous state variables are distributed uniformly
# in the interval +/- std/sqrt(1-rho_nu**2)
if grid_source == "mat":
_path = os.path.join(DIR, "random_grids.mat")
s = loadmat(_path)["random_grids"][:m, :]
else:
s = np.random.rand(m, 8)
sη = s[:, :6]
η = (-2*σ + 4*σ*sη) / np.sqrt(1-ρ**2)
# Values of endogenous state variables are distributed uniformly
# in the intervals [1 1.05] and [0.95 1], respectively
R = 1 + 0.05 * s[:, 6]
δ = 0.95 + 0.05 * s[:, 7]
ηR = η[:, 0]
ηa = η[:, 1]
ηL = η[:, 2]
ηu = η[:, 3]
ηB = η[:, 4]
ηG = η[:, 5]
self.ηR = ηR
self.ηa = ηa
self.ηL = ηL
self.ηu = ηu
self.ηB = ηB
self.ηG = ηG
self.R = R
self.δ = δ
# shape (8, m)
self.X = np.vstack([np.log(R), np.log(δ), η.T])
# shape (n_complete(8, p.Degree), m)
self.X0_G = {
1: complete_polynomial(self.X, 1),
p.degree: complete_polynomial(self.X, p.degree)
}
# shape (2*n=12, n=6)
self.ϵ_nodes, self.ω_nodes = qnwmonomial1(p.vcov)
# all shape (len(ϵ_nodes), m)
self.ηR1 = p.ρηR * ηR[None, :] + self.ϵ_nodes[:, None, 0]
self.ηa1 = p.ρηa * ηa[None, :] + self.ϵ_nodes[:, None, 1]
self.ηL1 = p.ρηL * ηL[None, :] + self.ϵ_nodes[:, None, 2]
self.ηu1 = p.ρηu * ηu[None, :] + self.ϵ_nodes[:, None, 3]
self.ηB1 = p.ρηB * ηB[None, :] + self.ϵ_nodes[:, None, 4]
self.ηG1 = p.ρηG * ηG[None, :] + self.ϵ_nodes[:, None, 5]
def generate_dataset(self, metabolite_names, n_samples, overwrite=False, checkpoint=None, save_dir=None):
if n_samples <= 0:
raise Exception('n_samples must be greater than 0! (%d)' % (n_samples))
if save_dir is not None and checkpoint is None:
raise Exception('Save directory has been set, but checkpoint has not! Please set it. ')
if checkpoint is not None and save_dir is None:
raise Exception('If you are setting a checkpoint for saving, you must specisify where you want them to '
'be saved (directory=None)')
if len(self.spectra):
if overwrite:
print('Overwriting current dataset, as overwrite set to true.')
self.spectra = []
else:
raise Exception('This dataset already has spectra associated with it, either set overwrite=True or '
'make a new dataset with the same basis for a different config.')
n_metabolites = len(metabolite_names)
for spectra in self.basis.spectra:
if len(spectra.metabolite_names) > 1:
raise Exception(
'Spectra in basis set cannot have more than one metabolite in if you want to generate a dataset.')
if np.min(spectra.nu()) > self.high_ppm:
raise Exception('Spectra does not reach the required max frequency axis (%.2f) for export: %.2f' % (np.min(spectra.nu()), self.high_ppm))
elif np.max(spectra.nu()) < self.low_ppm:
raise Exception('Spectra does not reach the required max frequency axis (%.2f) for export: %.2f' % (np.max(spectra.nu()), self.low_ppm))
if n_metabolites > len(self.basis.spectra):
raise Exception('Number of metabolite names is greater than the number of spectra in the basis.')
if len(metabolite_names) != len(set(metabolite_names)):
raise Exception('At least one metabolite name appears more than once in the list: ' + str(metabolite_names))
# filter the spectra to make sure it only contains metabolites in the metabolite names list, or a
# combination of them any additional metabolites are removed
spectra_to_keep = []
for ii in range(0, len(self.basis.spectra)):
if len(self.basis.spectra[ii].metabolite_names) <= len(metabolite_names):
# checks if every metabolite name in the spectra is also in the metabolite_names list
if all([smn in metabolite_names for smn in self.basis.spectra[ii].metabolite_names]):
spectra_to_keep.append(self.basis.spectra[ii])
if not len(spectra_to_keep):
raise Exception('No spectra selected to keep!')
self.basis.spectra = spectra_to_keep
self.basis.setup()
# now we've prepped the basis set time to set up the dataset.
self.linewidth = self.basis.spectra[0].linewidth
if self.conc_gen_method == 'random all':
# verstion where all metabolites can be excited
concentrations = np.random.ranf((n_samples, n_metabolites))
concentrations = (concentrations.T / np.sum(concentrations, 1)).T
elif self.conc_gen_method == 'random partial':
# version where not all metabolites are excited
concentrations = np.zeros((n_samples, n_metabolites))
# decide how many metabolites will be excited for each concentraion
n_excited_samples = np.random.randint(1, n_metabolites + 1, size=n_samples)
# concentrations for each of the aformentioned metabolites
excited_samples = [sorted(np.random.choice(range(n_metabolites), n_s, replace=False)) for n_s in
n_excited_samples]
for c, e in zip(concentrations, excited_samples):
c[e] = np.random.ranf(len(e))
# normalise the concentration to be a percentage for each (softmax output from CNN) (sum = 1)
concentrations = (concentrations.T / np.sum(concentrations, 1)).T
elif self.conc_gen_method == 'random uniform':
# version where there is uniform sampling across the number of excited metabolites
concentrations = np.zeros((n_samples, n_metabolites))
n_samples_per_div = int(np.ceil(n_samples / float(n_metabolites)))
samples = []
for n_excited_metabolites in range(1, n_metabolites + 1):
samples.extend(
[sorted(np.random.choice(range(n_metabolites), n_excited_metabolites, replace=False)) for _ in
range(n_samples_per_div)])
for ii, e in zip(range(n_samples), samples):
concentrations[ii][e] = np.random.ranf(len(e))
elif self.conc_gen_method == 'sobol':
concentrations = sobol_seq.i4_sobol_generate(n_metabolites, n_samples)
else:
raise Exception('Unknown concentration generation method: ' + self.conc_gen_method)
for count in range(n_samples):
# then export the combination and add it to the dataset
self.add_spectra(self.basis.export_combination(concentrations[count],
metabolite_names,
acquisitions=self.export_acquisitions))
# checkpointing for saving large dataset objects, if specified
if checkpoint is not None and count > 0:
if (count % checkpoint == 0) or (count == (n_samples - 1)):
self.check()
spectra, labels, export_labels = self.export_to_keras()
self.save_compressed(save_dir, spectra, labels)
self.spectra = []
if checkpoint is None:
self.check()
else:
return self.get_save_folder_name()
pt) * distToAxis(pt)**2
sobolCumulativeInertias = []
# instead of bins, we can try a low discrepancy sequence like the sobol sequence, which I think
# was made for applications like this one
sobolTrials = 20
for j in range(1, sobolTrials):
print('sobol trial ' + str(j))
# the sobel sequence returns a deterministic list of numbers, thus to test convergence we must
# vary the number of sampling points
subSampleSize = j**3 * samplesPerBin
# recalculated as above
sampleVolume = (2 * r)**3 / subSampleSize
# generate the first "subSampleSize" numbers of the sobel sequence in R^3
seq = sobol_seq.i4_sobol_generate(3, subSampleSize)
# check out sobel_projections.py. In general, the projections onto an arbitrary plane is not garunteed
# to be good at all... Thus we will just rotate our sobol sequence to line up with the axis (of moment of inertia)
v1 = np.array([1, 0, 0])
v2 = np.array([0, 1, 0])
normal = np.array([
axis[1][0] - axis[0][0], axis[1][1] - axis[0][1],
axis[1][2] - axis[0][2]
])
nonParallel = v2 if angle(v1, normal) < angle(v2, normal) else v1
perp1 = np.cross(normal, nonParallel)
perp2 = np.cross(normal, perp1)
perp3 = normalize(normal)
def qmc_driver() -> None:
"""A driver for quasi-Monte Carlo Uncertainty Quantification.
This component attaches to a collection of model instances, and
feeds in different parameter values generated using a Sobol
sequence.
"""
instance = Instance({
Operator.O_I: ['parameters_out[]'],
Operator.S: ['states_in[]']
})
while instance.reuse_instance():
# F_INIT
# get and check parameter distributions
n_samples = instance.get_setting('n_samples', 'int')
d_min = instance.get_setting('d_min', 'float')
d_max = instance.get_setting('d_max', 'float')
k_min = instance.get_setting('k_min', 'float')
k_max = instance.get_setting('k_max', 'float')
if d_max < d_min:
instance.error_shutdown('Invalid settings: d_max < d_min')
exit(1)
if k_max < k_min:
instance.error_shutdown('Invalid settings: k_max < k_min')
exit(1)
# generate UQ parameter values
sobol_sqn = sobol_seq.i4_sobol_generate(2, n_samples)
ds = d_min + sobol_sqn[:, 0] * (d_max - d_min)
ks = k_min + sobol_sqn[:, 1] * (k_max - k_min)
# configure output port
if not instance.is_resizable('parameters_out'):
instance.error_shutdown(
'This component needs a resizable'
' parameters_out port, but it is connected to'
' something that cannot be resized. Maybe try'
' adding a load balancer.')
exit(1)
instance.set_port_length('parameters_out', n_samples)
# run ensemble
Us = None
# O_I
for sample in range(n_samples):
uq_parameters = Settings({'d': ds[sample], 'k': ks[sample]})
msg = Message(0.0, None, uq_parameters)
instance.send('parameters_out', msg, sample)
# S
for sample in range(n_samples):
msg = instance.receive_with_settings('states_in', sample)
U = np.array(msg.data)
# accumulate
if Us is None:
Us = U
else:
Us = np.vstack((Us, U))
mean = np.mean(Us, axis=0)
plt.figure()
plt.imshow(np.log(Us + 1e-20))
plt.show()
# -*- coding: utf-8 -*-
"""
Created on Thu Jan 24 19:36:54 2019
@author: Christof
"""
import numpy as np
import sobol_seq
import matplotlib.pyplot as plt
random = np.random.rand(1024, 3)
sobol = sobol_seq.i4_sobol_generate(3, 1024)
print(random.shape)
print(sobol.shape)
rand_dist = plt.figure()
plt.title('Example 3D Distribution of Random Points')
plt.subplots_adjust(wspace=0, hspace=0)
for i in range(3):
plt.subplot(3, 3, i+1)
plt.plot(random[:, 0], random[:, i], 'b,')
plt.tick_params(axis='both', which='both',
bottom=False, top=False, right=False, left=False,
labelbottom=False, labeltop=False, labelright= False,
labelleft=False)
plt.subplot(3, 3, i+4)
plt.plot(random[:, 1], random[:, i], 'g,')
plt.tick_params(axis='both', which='both',
bottom=False, top=False, right=False, left=False,
import importance
import controlVariates
# Parametros de f(x)
alpha = 0.534548064
beta = 0.9350011
gReal = 0.6804991098 # Valor real da integral. Nao usado no criterio de parada,
# apenas na verificacao posterior do erro relativo.
name = ["CRUDE", "HIT OR MISS", "IMPORTANCE SAMPLING", "CONTROL VARIATES"]
g = [0, 0, 0, 0]
n = [0, 0, 0, 0]
# Sequencia de Sobol uniforme em 2 dimensoes
sobolSeq = sobol_seq.i4_sobol_generate(2, 25000)
# Sequencia de Sobol com distribuicao Beta
a = 1
b = 1.5
distribution = chaospy.Beta(a, b)
betaSeq = distribution.sample(25000, 'S')
# Recebe o valor esperado de gamma e o numero de iteracoes por metodo
g[0], n[0] = crude.run(alpha, beta, sobolSeq)
g[1], n[1] = hitOrMiss.run(alpha, beta, sobolSeq)
g[2], n[2] = importance.run(alpha, beta, betaSeq)
g[3], n[3] = controlVariates.run(alpha, beta, sobolSeq)
for i in range(len(g)):
print(name[i])
print("Estimativa de gamma: " + str(g[i]))
def tiktak(*,
N,
N_st,
xfix=None,
skip_global=False,
skip_local=False,
resume_global=False,
resume_local=False):
xl, xu, x0, keys, translator = calibration_params(xfix=xfix)
#Initial cheks
assert len(xl) == len(xu)
assert N >= N_st
x0 = np.array(x0)
############################################
#1 INITIALIZATION
###########################################
if not skip_global:
#First Create a Sobol Sequence
init = sobol_seq.i4_sobol_generate(
len(xl), N) # generate many draws from uniform
#init=init[:,0]
#Get point on the grid
x_init = xl * (1 - init) + xu * init
x_init = x_init.T
x_init = x_init.squeeze()
#Get fitness of initial points
pts = [('compute', translator(x_init[:, j])) for j in range(N)]
fx_init = compute_for_values(pts, resume=resume_global)
fx_init = (np.array(fx_init)).squeeze()
# !! not the optimizer returns squared value of mdl_resid
#Sort in ascending order of fitness
order = np.argsort(fx_init)
fx_init = fx_init[order]
x_init = x_init[:, order]
filer('sobol_results.pkl', (fx_init, x_init), True)
print('saved the results succesfully')
else:
(fx_init, x_init0) = filer('sobol_results.pkl', None, False)
# this block appends variables if too little are specified in sobol_results
x_init = np.zeros((x0.size, x_init0.shape[1]), dtype=x_init0.dtype)
x_init[:, :] = x0[:, None]
x_init[0:(x_init0.shape[0]), :] = x_init0
print('loaded the results from the file')
#Take only the first N_st realization
fx_init = fx_init[0:N_st]
x_init = x_init[:, 0:N_st]
if skip_local:
print('local minimizers are skipped')
return x_init[:, 0]
#Create a file with sobol sequence points
filer('sobol.pkl', x_init, True)
if not resume_local:
#List containing parameters and save them in file
param = list([(fx_init[0], x_init[:, 0])])
filer('wisdom.pkl', param, True)
i_start = 0
else:
param = filer('wisdom.pkl', None, False)
i_start = len(param)
vals = [('minimize', (i, N_st, xfix)) for i in range(i_start, N_st)]
compute_for_values(vals, timeout=7200.0)
param = filer('wisdom.pkl', None, write=False)
############################################
#3 TOPPING RULE
###########################################
#print(999,ite)
#Final Refinement
return param[0]
def diferentialEvolution(self, pop_size, dim, max_iterations, runs, func, f, nfunc, maximize=True):
crowding_target = 0
neighborhood_list = []
funcs = ["haha", "five_uneven_peak_trap", "equal_maxima", "uneven_decreasing_maxima", "himmelblau", "six_hump_camel_back", "shubert", "vincent", "shubert", "vincent", "modified_rastrigin_all", "CF1", "CF2", "CF3", "CF3", "CF4", "CF3", "CF4", "CF3", "CF4", "CF4"]
#print(">>>>>>>>>>", str(funcs[1]))
m = 0
PR = [] #PEAK RATIO
SR = 0.0
#generate execution identifier
#uid = uuid.uuid4()
hora = strftime("%Hh%Mm%S", localtime())
mkdir(str(funcs[nfunc]) + '_' + str(dim) + 'D_' + str(hora))
mkdir(str(funcs[nfunc]) + '_' + str(dim) + 'D_' + str(hora) +'/graphs')
#to record the results
results = open(str(funcs[nfunc]) + '_' + str(dim) + 'D_' + str(hora) + '/results.txt', 'a')
records = open(str(funcs[nfunc]) + '_' + str(dim) + 'D_' + str(hora) + '/records.txt', 'a')
results.write('ID: %s\tDate: %s\tRuns: %s\n' % (str(funcs[nfunc] ), strftime("%Y-%m-%d %H:%M:%S", gmtime()), str(runs)))
results.write('=================================================================================================================\n')
records.write('ID: %s\tDate: %s\tRuns: %s\n' % (str(funcs[nfunc] ), strftime("%Y-%m-%d %H:%M:%S", gmtime()), str(runs)))
records.write('=================================================================================================================\n')
avr_fbest_r = []
avr_diversity_r = []
fbest_r = []
best_r = []
elapTime_r = []
#runs
for r in range(runs):
count_global = 0.0
elapTime = []
start = time()
records.write('Run: %i\n' % r)
records.write('Iter\tGbest\tAvrFit\tDiver\tETime\t\n')
#start the algorithm
best = [] #global best positions
fbest = 0.00
#global best fitness
if maximize == True:
fbest = 0.00
else:
fbest = math.inf
sobol = ss.i4_sobol_generate(dim, pop_size)
#initial_generations
self.generatePopulation(pop_size, dim, f, sobol)
#fpop = f.evaluate
fpop = self.evaluatePopulation(func, f)
for ind in range(pop_size):
self.euclidean_distance_full(self.pop[ind], ind, dim)
fbest,best = self.getBestSolution(maximize, fpop)
#evolution_step
# generates crossover rate values
crm = 0.5
Fl = 0.1
Fu = 0.9
tau1 = tau2 = 0.1
crossover_rate = [gauss(crm, 0.1) for i in range(pop_size)]
mutation_rate = [0.5] * pop_size
cr_list = []
for iteration in range(max_iterations):
print(iteration)
if pop_size <= 200:
m=math.floor(5+20*((max_iterations-iteration)/max_iterations))
else:
m=math.floor(5+20*((max_iterations-iteration)/max_iterations))
avrFit = 0.00
# #update_solutions
strategy = 0
#print(mutation_rate)
#print(crossover_rate)
#sleep(5)
for ind in range(0,len(self.pop)):
rand1 = uniform(0, 1)
rand2 = uniform(0, 1)
rand3 = uniform(0, 1)
rand4 = uniform(0, 1)
if rand2 < tau1:
mutation_rate[ind] = Fl + (rand1 * Fu)
if rand4 < tau2:
crossover_rate[ind] = rand3
# generate weight factor values
weight_factor = gauss(0.5, 0.3)
#weight_factor = 0.5
#crossover_rate[ind] = 0.1
if uniform(0,1) < 1:
neighborhood_list = self.generate_neighborhood(ind, m, dim, f)
candSol = self.rand_1_bin(self.pop[ind], ind, dim, mutation_rate[ind], crossover_rate[ind], neighborhood_list, m)
#candSol = self.currentToRand_1_bin(self.pop[ind], ind, dim, mutation_rate[ind], crossover_rate[ind], neighborhood_list, m)
self.boundsRes(candSol, f, dim)
fcandSol = f.evaluate(candSol)
dist, crowding_target = self.euclidean_distance(candSol, ind, dim, f, fpop)
if maximize == True:
if fcandSol >= fpop[crowding_target]:
self.pop[crowding_target] = candSol
dist_correta, aux = self.euclidean_distance(candSol, crowding_target, dim, f, fpop)
self.full_euclidean[crowding_target] = dist_correta
fpop[crowding_target] = fcandSol
avrFit += fpop[crowding_target]
avrFit = avrFit/pop_size
self.diversity.append(0)
fbest,best = self.getBestSolution(maximize, fpop)
self.fbest_list.append(fbest)
elapTime.append((time() - start)*1000.0)
records.write('%i\t%.4f\t%.4f\t%.4f\t%.4f\n' % (iteration, round(fbest,4), round(avrFit,4), round(self.diversity[iteration],4), elapTime[iteration]))
# if iteration%crPeriod == 0 and iteration!=0:
# crossover_rate = [gauss(crm, 0.1) for i in range(pop_size)]
# if iteration%crmUpdatePeriod == 0:
# crm = sum(cr_list)/len(cr_list)
# cr_list = []
records.write('Pos: %s\n\n' % str(best))
fbest_r.append(fbest)
best_r.append(best)
elapTime_r.append(elapTime[max_iterations-1])
self.generateGraphs(self.fbest_list, self.diversity, max_iterations, funcs[nfunc], r, dim, hora)
avr_fbest_r.append(self.fbest_list)
avr_diversity_r.append(self.diversity)
pop_aux = []
pop_aux = self.pop
count, seeds = how_many_goptima(self.pop, f, 0.001, len(self.pop), pop_aux)
#print(count, seeds)
count_global += count
self.pop = []
self.m_nmdf = 0.00
self.diversity = []
self.fbest_list = []
p1 = p2 = 0.5
self.nf2 = 1
self.ns1 = 1
self.ns2 = 1
self.nf1 = 1
print("ENTROu")
PR.append(count_global/f.get_no_goptima())
print(PR[r])
if(PR[r] == 1):
SR += 1
fbestAux = [sum(x)/len(x) for x in zip(*avr_fbest_r)]
diversityAux = [sum(x)/len(x) for x in zip(*avr_diversity_r)]
self.generateGraphs(fbestAux, diversityAux, max_iterations, funcs[nfunc], 'Overall', dim, hora)
records.write('=================================================================================================================')
if maximize==False:
results.write('Gbest Overall: %.4f\n' % (min(fbest_r)))
results.write('Positions: %s\n\n' % str(best_r[fbest_r.index(min(fbest_r))]))
else:
results.write('Tamanho da populacao: %d\n' % pop_size)
results.write('Iteracoes Maximas: %d\n' % max_iterations)
results.write('Funcao Otimizada: %s\n' % func)
results.write('Gbest Overall: %.4f\n' % (max(fbest_r)))
results.write('Positions: %s\n' % str(best_r[fbest_r.index(max(fbest_r))]))
for i in range(0, runs):
results.write('Mean Peaks Found on Run %d: %f (%f)\n' % (i, PR[i], (PR[i]*f.get_no_goptima())))
if runs > 1:
results.write('Mean Peaks Found: %.4f\n' % (sum(PR)/runs))
results.write('Peak Ratio Standard Deviation: %.4f\n' % (stdev(PR)))
results.write('[')
for i in range(0, runs):
results.write('%.5f, ' % PR[i])
results.write(']\n')
results.write('Success rate: %.4f\n\n' % (SR/runs))
results.write('Gbest Average: %.4f\n' % (sum(fbest_r)/len(fbest_r)))
results.write('Gbest Median: %.4f #probably should use median to represent due probably non-normal distribution (see Shapiro-Wilk normality test)\n' % (median(fbest_r)))
if runs > 1:
results.write('Gbest Standard Deviation: %.4f\n\n' % (stdev(fbest_r)))
results.write('Elappsed Time Average: %.4f\n' % (sum(elapTime_r)/len(elapTime_r)))
if runs > 1:
results.write('Elappsed Time Standard Deviation: %.4f\n' % (stdev(elapTime_r)))
results.write('=================================================================================================================\n')
def generate(self, dim_num, n):
randoms = i4_sobol_generate(dim_num, n, skip=self.skip)
self.skip += dim_num * n
return randoms
# -*- coding: utf-8 -*-
"""
Created on Thu Feb 6 19:45:14 2020
@author: Christof
"""
import numpy as np
import sobol_seq
import matplotlib.pyplot as plt
import scipy
random = np.random.rand(512, 2)
sobol = sobol_seq.i4_sobol_generate(2, 512)
print(random.shape)
print(sobol.shape)
rand_dist = plt.figure()
plt.title('Example 2D Distribution of Random Points')
plt.plot(random[:, 0], random[:, 1], 'bo', mfc='none')
plt.savefig('2D_Dist_Rand512.pdf', format='pdf')
plt.show()
sov_dist = plt.figure()
plt.title('Example 2D Distribution of Sobol Points')
plt.plot(sobol[:, 0], sobol[:, 1], 'bo', mfc='none')
plt.savefig('2D_Dist_Sobol512.pdf', format='pdf')
plt.show()
v2 = np.array([0, 1, 0])
nonParallel = v2 if angle(v1, planeNormal) < angle(v2, planeNormal) else v1
perp1 = np.cross(planeNormal, nonParallel)
perp2 = np.cross(planeNormal, perp1)
perp3 = normalize(planeNormal)
perp1 = normalize(perp1)
perp2 = normalize(perp2)
return la.inv(np.column_stack([perp1, perp2, perp3]))
def planeCoord(pt, projMat):
transformed = np.dot(projMat, np.column_stack([pt]))
return [transformed[0][0], transformed[1][0]]
sobelPts = sobol_seq.i4_sobol_generate(3, 1000)
for k in range(7):
normal = planeNormals[k]
mat = projectMatrix(normal)
pts = []
for pt in sobelPts:
if (pt[0] - .5)**2 + (pt[1] - .5)**2 + (pt[2] - .5)**2 < .5**2:
pts.append(planeCoord(pt, mat))
[xs, ys] = np.array(pts).transpose()
plt.subplot(3, 3, k + 1)
plt.plot(xs, ys, 'ro')
plt.show()
from benchmark_functions import branin,Currin
functions=[branin,Currin]
d=2
referencePoint = [1e5]*len(functions)
total_iterations=100
seed=0
np.random.seed(seed)
intial_number=1
bound=[0,1]
sample_number=1
Fun_bounds = [bound]*d
grid = sobol_seq.i4_sobol_generate(d,1000,np.random.randint(0,100))
design_index = np.random.randint(0, grid.shape[0])
###################GP Initialisation##########################
GPs=[]
Multiplemes=[]
for i in range(len(functions)):
GPs.append(GaussianProcess(d))
for k in range(intial_number):
exist=True
while exist:
design_index = np.random.randint(0, grid.shape[0])
x_rand=list(grid[design_index : (design_index + 1), :][0])
if (any((x_rand == x).all() for x in GPs[0].xValues))==False:
exist=False
import numpy as np
import matplotlib.pyplot as plt
import sobol_seq
import scipy.stats
fig, ax = plt.subplots(nrows=3, ncols=5)
#Uniform Distribution
axes = plt.subplot(3,5,1)
N = 50
norm = sobol_seq.i4_sobol_generate(1, N)
axes.set_title('N=50')
axes.set_ylabel('Uniform')
plt.hist(norm, bins=N)
axes = plt.subplot(3,5,2)
N = 100
norm = sobol_seq.i4_sobol_generate(1, N)
axes.set_title('N=100')
plt.hist(norm, bins=N)
axes = plt.subplot(3,5,3)
N = 250
norm = sobol_seq.i4_sobol_generate(1, N)
axes.set_title('N=250')
plt.hist(norm, bins=N)
axes = plt.subplot(3,5,4)
N = 500
norm = sobol_seq.i4_sobol_generate(1, N)
scores = lines[1].split(",")
MPE_train = float(scores[0])
mean_train = mean_train + MPE_train**2
if model_type == "net":
model = Utils.load_data(new_path)
else:
model = joblib.load(new_path + "/model_GP.sav")
minmax = pd.read_csv(new_path + "/MinMax.txt", header=0)
min_val = minmax.Min.values[0]
max_val = minmax.Max.values[0]
if point == "random":
preds = model.predict(np.random.uniform(0, 1, (1000, 7)))
elif point == "sobol":
preds = model.predict(sobol_seq.i4_sobol_generate(7, 1000))
else:
raise ValueError()
std_app = np.std(preds * (max_val - min_val) + min_val)
print("True STD: ", std)
print("Appr STD: ", std_app)
'''
prod = 1
for j in range(len(model.layers)):
if model.layers[j].get_weights():
weight_matrix = model.layers[j].get_weights()[0]
# for k in range(weight_matrix.shape[1]):
# print(weight_matrix[:,k])
# print(sum(abs(weight_matrix[:,k])))
# print(weight_matrix.shape)
def Quasi_Monte_Carlo_Simulation(no_of_trials, T, r, S_0, vol, K, q, m,
batch): #m是分几个interval
def quasi_get_Gaussian(u1, u2):
output_u1 = math.sqrt(-2.0 * math.log(u1)) * math.cos(
6.283185307999998 * u2)
output_u2 = math.sqrt(-2.0 * math.log(u1)) * math.sin(
6.283185307999998 * u2)
return [output_u1, output_u2]
itval = T / m
quasi_mean = quasi_mean_square = 0
option_price_list = []
for _ in range(batch):
sobel = sobol_seq.i4_sobol_generate(m, no_of_trials)
#生成一个shape 为 no_of_trials * m 的np.array()
random_var = np.zeros((no_of_trials, m))
#生一个numpy array, shape 为no_of_trials * m
sim_option_price_sum = 0.0
for i in range(no_of_trials):
#print( random_var.shape, sobel.shape,len(random_var[i]), len(sobel[:,i]))
random_var[i] = sobel[i] + np.random.uniform(
0, 1, m) #把sobel 所有第i行数据加上一个 uniform variable
random_var[i] = random_var[i] - np.floor(
random_var[i]) #让 所有第i行数据 都小于0
#np.floor([2.8,1.2]) = np.array([2，1])
random_var[i, 0:2] = quasi_get_Gaussian(*random_var[i, 0:2])
# * 号表示unload list 元素到variable, 也可以写成quasi_get_Gaussian(random_var[i,0],random_var[i,1] )
average = price = S_0 * math.exp(
(r - q - 0.5 * vol**2) * itval +
vol * random_var[i, 0] * itval**0.5)
for j in range(m - 1):
if j % 2 == 1:
random_var[i, j + 1:j + 3] = quasi_get_Gaussian(
*random_var[i, j + 1:j + 3])
price = price * math.exp((r - q - 0.5 * vol**2) * itval + vol *
random_var[i, j + 1] * itval**0.5)
average += price
average = average / m
simulated_option_price = math.exp(-r * T) * max(average - K, 0)
sim_option_price_sum += simulated_option_price
option_price_list.append(average)
option_price = average / no_of_trials
quasi_mean += option_price
quasi_mean_square += option_price * option_price
quasi_mean = quasi_mean / batch
quasi_mean_square = quasi_mean_square / batch
option_price_list = np.array(option_price_list)
std_err = math.sqrt(1 / batch * np.sum(
(option_price_list - quasi_mean) * 2) / (batch - 1))
#把list中每个option price 减去quasi_mean 再平方
upper_bound = quasi_mean + 1.96 * std_err
lower_bound = quasi_mean - 1.96 * std_err
print(
"Quasi Monte Carlo option price = {0}, standard_error = {1}, Confidence Interval = [{2:.3f}, {3:.3f}] "
.format(option_price, std_err, upper_bound, lower_bound))
# 1st row 4th plot
axes[0, 3].scatter(np.random.rand(d), np.random.rand(d), color = 'black', s = 1)
axes[0, 3].set_aspect('equal', 'box')
axes[0, 3].set_xlabel("N = " + str(d))
axes[0, 3].xaxis.set_label_position('top')
# 1st row 5th plot
axes[0, 4].scatter(np.random.rand(e), np.random.rand(e), color = 'black', s = 1)
axes[0, 4].set_aspect('equal', 'box')
axes[0, 4].set_xlabel("N = " + str(e))
axes[0, 4].xaxis.set_label_position('top')
# Generating Quasi-Random numbers
soba = ss.i4_sobol_generate(2, a)
sobb = ss.i4_sobol_generate(2, b)
sobc = ss.i4_sobol_generate(2, c)
sobd = ss.i4_sobol_generate(2, d)
sobe = ss.i4_sobol_generate(2, e)
# 2nd row 1st plot
axes[1, 0].scatter(soba[:, 0], soba[:, 1], color = 'black', s = 1)
axes[1, 0].set_aspect('equal', 'box')
axes[1, 0].set_ylabel("Quasi-Random")
# 2nd row 2nd plot
axes[1, 1].scatter(sobb[:, 0], sobb[:, 1], color = 'black', s = 1)
axes[1, 1].set_aspect('equal', 'box')
# 2nd row 3rd plot
def __init__(self,nogrid=False,**kwargs):
p = dict()
p['T'] = 2
p['sig_zf_0'] = 0.15
p['sig_zf'] = 0.05
p['n_zf'] = 3
p['sig_zm_0'] = 0.15#0.2
p['sig_zm'] = 0.05#0.075
p['n_zm'] = 3
p['sigma_psi_init'] = 0.12
p['sigma_psi'] = 0.03
p['n_psi'] = 7
p['beta'] = 0.95
p['A'] = 1.2 # consumption in couple: c = (1/A)*[c_f^(1+rho) + c_m^(1+rho)]^(1/(1+rho))
p['crra_power'] = 1.5
p['couple_rts'] = 0.0
p['sig_partner_a'] = 0.0#0.1
p['sig_partner_z'] = 0.2
p['m_bargaining_weight'] = 0.5
for key, value in kwargs.items():
assert (key in p), 'wrong name?'
p[key] = value
p['nexo'] = p['n_zf']*p['n_zm']*p['n_psi']
self.pars = p
p_int = dict()
# relevant for integration (we do not do integration here)
# this one is for (a_part,z_part,psi_couple)
p_int['num_partners'] = 5
p_int['nodes_couple'] = norm.ppf(sobol_seq.i4_sobol_generate(3,p_int['num_partners']))
p_int['num_z_nodes'] = 7
p_int['z_nodes'] = norm.ppf(sobol_seq.i4_sobol_generate(1,p_int['num_z_nodes']))
p_int['large_3dim'] = norm.ppf(sobol_seq.i4_sobol_generate(3,60)) # generate many draws from normal
#Fabio modification
p_int['zf']=np.random.normal(0, 1, 100)
p_int['zm']=np.random.normal(0, 1, 100)
p_int['psi']=np.random.normal(0, 1, 100)
self.integration = p_int
if not nogrid:
exogrid = dict()
# let's approximate three Markov chains
# this sets up exogenous grid
exogrid['zf_t'], exogrid['zf_t_mat'] = rouw_nonst(p['T'],p['sig_zf'],p['sig_zf_0'],p['n_zf'])
exogrid['zm_t'], exogrid['zm_t_mat'] = rouw_nonst(p['T'],p['sig_zm'],p['sig_zm_0'],p['n_zm'])
exogrid['psi_t'], exogrid['psi_t_mat'] = rouw_nonst(p['T'],p['sigma_psi'],p['sigma_psi_init'],p['n_psi'])
zfzm, zfzmmat = combine_matrices_two_lists(exogrid['zf_t'], exogrid['zm_t'], exogrid['zf_t_mat'], exogrid['zm_t_mat'])
exogrid['all_t'], exogrid['all_t_mat'] = combine_matrices_two_lists(zfzm,exogrid['psi_t'],zfzmmat,exogrid['psi_t_mat'])
exogrid['all_t_mat_sparse_T'] = [sparse.csc_matrix(D.T) if D is not None else None for D in exogrid['all_t_mat']]
Exogrid_nt = namedtuple('Exogrid_nt',exogrid.keys())
self.nexo = p['nexo']
self.exogrid = Exogrid_nt(**exogrid)
self.na = 60
self.amin = 0
self.amax = 1.5
self.agrid = np.linspace(self.amin,self.amax,self.na)
# grid for theta
self.ntheta = 71
self.thetamin = 0.0001
self.thetamax = 0.9999
self.thetagrid = np.linspace(self.thetamin,self.thetamax,self.ntheta)
def getStratifiedPointsH2(n, num_stratas, phi = False, theta = True, withLowDis = False):
num_stratas = np.int32(num_stratas)
samplesPerStrata = np.int32(n/num_stratas)
omega = np.zeros([n, 2])
if (withLowDis):
num_stratasPhi = 8
num_stratasTheta = np.int32(num_stratas/num_stratasPhi)
index = 0
sobolpoints = sobol_seq.i4_sobol_generate(2, samplesPerStrata)
#slice sphere in theta and phi
for i in range(num_stratasPhi):
for j in range(num_stratasTheta):
rand = sobolpoints.copy()
rand[:, 0] = np.arccos(rand[:, 0]/num_stratasTheta + j/num_stratasTheta)
rand[:, 1] = (rand[:,1]/num_stratasPhi + i/num_stratasPhi) * 2 * np.pi
omega[index*samplesPerStrata:(index+1)*samplesPerStrata] = rand
index += 1
return omega
if (phi and theta):
num_stratasPhi = 8
num_stratasTheta = np.int32(num_stratas/num_stratasPhi)
index = 0
#slice sphere in theta and phi
for i in range(num_stratasPhi):
for j in range(num_stratasTheta):
for k in range(samplesPerStrata):
rand = np.random.rand(2)
rand[0] = np.arccos(rand[0]/num_stratasTheta + j/num_stratasTheta)
rand[1] = rand[1]/num_stratasPhi + i/num_stratasPhi
omega[index, 0] = rand[0]
omega[index, 1] = rand[1] * 2 * np.pi
index += 1
return omega
elif (phi):
#sphere in num_stratas slices in phi direction
for i in range(num_stratas):
for j in range(samplesPerStrata):
rand = np.random.rand(2)
rand[1] = rand[1]/num_stratas + i/num_stratas
omega[i*samplesPerStrata+j, 0] = np.arccos(rand[0])
omega[i*samplesPerStrata+j, 1] = rand[1] * 2 * np.pi
return omega
else:
#sphere in num_stratas slices in theta direction
for i in range(num_stratas):
for j in range(samplesPerStrata):
rand = np.random.rand(2)
omega[i*samplesPerStrata+j, 0] = np.arccos(rand[0]/num_stratas + i/num_stratas)
omega[i*samplesPerStrata+j, 1] = rand[1] * 2 * np.pi
return omega
#filename_list = ["Midline_40_0.csv","Midline_40_1.csv","Midline_40_2.csv","Midline_40_3.csv","Midline_40_4.csv","Midline_40_5.csv"]
filename_list = ["Midline_40_0.csv"]
elif myrads == 80:
#removing _80_0 because of unusual yawrate changes.
#removing _80_1 because the balanced portion of the experiment uses it.
filename_list = ["Midline_80_2.csv","Midline_80_3.csv","Midline_80_4.csv","Midline_80_5.csv"]
else:
raise Exception('Unrecognised radius')
Trials = 24
sobol = sobol_seq.i4_sobol_generate(4, Trials) # 0,1 scale
#print(sobol_3D)
#rescale
onset_sobol = sobol[:,2] * 4 + 5
autofile_sobol = np.round(sobol[:,1] * 3,0)
ttlc_limit = 2
ttlc_stay = 18
ttlc_sobol = sobol[:,0] * (ttlc_stay-ttlc_limit) + ttlc_limit
steer_sobol = sobol[:,2] #flag for understeering or oversteering
#***** retrieve approximations of SAB ******
def generate_sobol_seq(dim,nSobol):
mysobol_seq = sobol_seq.i4_sobol_generate(dim, nSobol)
return mysobol_seq
import numpy as np
import sobol_seq
import matplotlib.pyplot as plt
#### SOBOL RANDOMISATION #######
#3 dimensional sobol sequence: SAB, Onset Time, Trajs
Trials = 30
sobol_3D = sobol_seq.i4_sobol_generate(3, 30) # 0,1 scale
print(sobol_3D)
#onset time pool to range between 5-9.
#autofile as integers 0-3.
#sab from -5 - +5
#OnsetTimePool_sobel = np.arange(5, 9.25, step = .25)
#OnsetTimePool = OnsetTimePool[OnsetTimePool[] != 6]
onset_sobol = sobol_3D[:, 0] * 4 + 5
autofile_sobol = np.round(sobol_3D[:, 1] * 3, 0)
sab_sobol = sobol_3D[:, 2] * 10 - 5
plt.figure(2)
plt.plot(sab_sobol, autofile_sobol, 'k.', markersize=5, alpha=.2)
plt.xlabel("Steering Angle Biases (deg/s)")
plt.ylabel("Onset Times (s)")
plt.title("Sobol samples")
plt.show()
