def initRun(self, run):
if run.params.qoi_knots.lower() == "uniform":
fnKnots = lambda beta: misc.knots_uniform(misc.lev2knots_linear(1+beta),
0, 1, 'nonprob')
else:
assert(run.params.qoi_knots.lower() == "cc")
fnKnots = lambda beta: misc.knots_CC(misc.lev2knots_doubling(1+beta),
0, 1, 'nonprob')
self.misc = misc.MISCSampler(d=0, fnKnots=fnKnots, min_dim=run.params.min_dim)
b = [9.0, 7.25, 1.85, 7.03, 2.04, 4.3]
fn = [self.func_oscillatory, self.func_productpeak,
self.func_cornerpeak, self.func_gauss, self.func_cont,
self.func_discont]
self.func = lambda inds, M, r=run: fn[run.params.qoi_func-1](r, inds, M)
np.random.seed(run.params.qoi_seed)
run.params.qoi_w = 1./np.arange(1.,run.params.qoi_dim+1, dtype=np.float)#np.random.random(size=run.params.qoi_dim)
run.params.qoi_c = np.arange(1,run.params.qoi_dim+1, dtype=np.float) #np.random.random(size=run.params.qoi_dim)
run.params.qoi_c *= b[run.params.qoi_func-1] / np.sum(run.params.qoi_c)
run.params.qoi_c = np.array([2.71,0.16,3.42,2.71])
run.params.qoi_w = np.array([0.42,0.72,0.01,0.3])
run.setFunctions(ExtendLvls=lambda lvls, r=run: self.extendLvls(run, lvls),
WorkModel=lambda lvls, r=run: self.workModel(run, lvls),
fnSampleLvl=self.mySampleQoI)
self.profCalc = setutil.TDProfCalculator(np.ones(run.params.qoi_dim))
return
def initRun(self, run):
fnKnots = lambda beta: misc.knots_CC(misc.lev2knots_doubling(1 + beta),
0, 1, 'nonprob')
self.misc = misc.MISCSampler(d=0,
fnKnots=fnKnots,
min_dim=run.params.min_dim)
b = [9.0, 7.25, 1.85, 7.03, 2.04, 4.3]
fn = [
self.func_oscillatory, self.func_productpeak, self.func_cornerpeak,
self.func_gauss, self.func_cont, self.func_discont
]
self.func = lambda inds, M, r=run: fn[run.params.qoi_func - 1](r, inds,
M)
np.random.seed(run.params.qoi_seed)
run.params.qoi_w = 1. / np.arange(
1., run.params.qoi_dim + 1,
dtype=np.float) #np.random.random(size=run.params.qoi_dim)
run.params.qoi_c = np.arange(
1, run.params.qoi_dim + 1,
dtype=np.float) #np.random.random(size=run.params.qoi_dim)
run.params.qoi_c *= b[run.params.qoi_func - 1] / np.sum(
run.params.qoi_c)
run.setFunctions(
ExtendLvls=lambda lvls, r=run: self.extendLvls(run, lvls),
WorkModel=lambda lvls, r=run: self.workModel(run, lvls),
fnSampleLvl=self.mySampleQoI)
self.profCalc = setutil.TDProfCalculator(np.ones(run.params.qoi_dim))
return
def extendLvls(self, run, lvls):
if len(lvls) == 0:
# First run, add min_lvls on each dimension
d = run.params.min_dim + self.extrapolate_s_dims
eye = np.eye(d, dtype=int)
new_lvls = np.vstack(
[np.zeros(d, dtype=int)] +
[i * eye for i in range(1, run.params.min_lvl)])
lvls.add_from_list(new_lvls)
return
import time
tStart = time.process_time()
# estimate rates
self.d_err_rates, \
s_fit_rates = misc.estimate_misc_error_rates(d=run.params.min_dim,
lvls=lvls,
errs=run.last_itr.calcDeltaEl(),
d_err_rates=self.d_err_rates,
lev2knots=lambda beta:misc.lev2knots_doubling(1+beta))
#################### extrapolate error rates
if s_fit_rates is not None:
valid = np.nonzero(
s_fit_rates > 1e-15
)[0] # rates that are negative or close to zero are not accurate.
N = len(s_fit_rates) + self.extrapolate_s_dims
k_of_N = self.transNK(run.params.qoi_dim, N,
run.params.qoi_problem)
K = np.max(k_of_N)
c = np.polyfit(np.log(1 + k_of_N[valid]), s_fit_rates[valid], 1)
k_rates_stoch = c[0] * np.log(1 + np.arange(0, K + 1)) + c[1]
s_err_rates = np.maximum(k_rates_stoch[k_of_N[:N]],
np.min(s_fit_rates[valid]))
s_err_rates[valid] = s_fit_rates[
valid] # The fitted rates should remain the same
else:
s_err_rates = []
tEnd_rates = time.process_time() - tStart
######### Update
tStart = time.process_time()
self.profCalc = setutil.MISCProfCalculator(
self.d_err_rates + self.d_work_rates, s_err_rates)
mimc.extend_prof_lvls(lvls, self.profCalc, run.params.min_lvl)
def extendLvls(self, run, lvls):
if len(lvls) == 0:
# First run, add min_lvls on each dimension
d = run.params.min_dim + self.extrapolate_s_dims
eye = np.eye(d, dtype=int)
new_lvls = np.vstack([np.zeros(d, dtype=int)] +
[i*eye for i in range(1, run.params.min_lvl)])
lvls.add_from_list(new_lvls)
return
import time
tStart = time.clock()
# estimate rates
self.d_err_rates, \
s_fit_rates = misc.estimate_misc_error_rates(d=run.params.min_dim,
lvls=lvls,
errs=run.last_itr.calcDeltaEl(),
d_err_rates=self.d_err_rates,
lev2knots=lambda beta:misc.lev2knots_doubling(1+beta))
#################### extrapolate error rates
if s_fit_rates is not None:
valid = np.nonzero(s_fit_rates > 1e-15)[0] # rates that are negative or close to zero are not accurate.
N = len(s_fit_rates) + self.extrapolate_s_dims
k_of_N = self.transNK(run.params.qoi_dim, N, run.params.qoi_problem)
K = np.max(k_of_N)
c = np.polyfit(np.log(1+k_of_N[valid]), s_fit_rates[valid], 1)
k_rates_stoch = c[0]*np.log(1+np.arange(0, K+1)) + c[1]
s_err_rates = np.maximum(k_rates_stoch[k_of_N[:N]],
np.min(s_fit_rates[valid]))
s_err_rates[valid] = s_fit_rates[valid] # The fitted rates should remain the same
else:
s_err_rates = []
tEnd_rates = time.clock() - tStart
######### Update
tStart = time.clock()
self.profCalc = setutil.MISCProfCalculator(self.d_err_rates +
self.d_work_rates,
s_err_rates)
mimc.extend_prof_lvls(lvls, self.profCalc, run.params.min_lvl)
def initRun(self, run):
self.prev_val = 0
self.extrapolate_s_dims = 0 if run.params.qoi_problem < 0 else 10
self.params = run.params
if run.params.qoi_problem < 0: # Fake mode for deterministic problem
run.params.qoi_problem = 0
fnKnots= lambda beta: misc.knots_CC(misc.lev2knots_doubling(1+beta),
-np.sqrt(3), np.sqrt(3))
self.misc = misc.MISCSampler(d=run.params.min_dim, fnKnots=fnKnots)
self.sf = SField_Matern(run.params)
self.d_err_rates = 2.*np.log(run.params.beta) * \
np.minimum(1, run.params.qoi_df_nu / run.params.qoi_dim)
self.d_work_rates = np.log(run.params.beta) * run.params.gamma
# self.profCalc = setutil.MISCProfCalculator(self.d_err_rates +
# self.d_work_rates,
# np.ones(self.extrapolate_s_dims))
run.setFunctions(ExtendLvls=lambda lvls, r=run: self.extendLvls(run, lvls),
WorkModel=lambda lvls, r=run: self.workModel(run, lvls))
return
def initRun(self, run):
self.prev_val = 0
self.extrapolate_s_dims = 0 if run.params.qoi_problem < 0 else 10
self.params = run.params
if run.params.qoi_problem < 0: # Fake mode for deterministic problem
run.params.qoi_problem = 0
fnKnots = lambda beta: misc.knots_CC(misc.lev2knots_doubling(1 + beta),
-np.sqrt(3), np.sqrt(3))
self.misc = misc.MISCSampler(d=run.params.min_dim, fnKnots=fnKnots)
self.sf = SField_Matern(run.params)
self.d_err_rates = 2.*np.log(run.params.beta) * \
np.minimum(1, run.params.qoi_df_nu / run.params.qoi_dim)
self.d_work_rates = np.log(run.params.beta) * run.params.gamma
# self.profCalc = setutil.MISCProfCalculator(self.d_err_rates +
# self.d_work_rates,
# np.ones(self.extrapolate_s_dims))
run.setFunctions(
ExtendLvls=lambda lvls, r=run: self.extendLvls(run, lvls),
WorkModel=lambda lvls, r=run: self.workModel(run, lvls))
return
