def calculate_moments(self, storage: SampleStorageHDF,
qspec: QuantitySpec):
"""
Calculate moments of given quantity for all times.
:param storage: Sample HDF storage
:param qspec: quantity given by QuantitySpec
:return: moments means estimates, their variances; tuple of 2 np.arrays of length 3
"""
n_moments = 3
means = []
vars = []
for time_id in range(len(qspec.times)):
true_domain = QuantityEstimate.estimate_domain(storage,
qspec,
time_id,
quantile=0.01)
# moments_fn = moments.Legendre(n_moments, true_domain)
# moments_fn = moments.Monomial(n_moments, true_domain)
# compute mean in real values (without transform to ref domain)
# mean_moment_fn = moments.Monomial.factory(2, domain=true_domain, ref_domain=true_domain, safe_eval=False)
# q_estimator = QuantityEstimate(sample_storage=storage, sim_steps=self.step_range,
# qspec=qspec, time_id=time_id)
# m, v = q_estimator.estimate_moments(mean_moment_fn)
#
# # The first moment is in any case 1 and its variance is 0
# assert m[0] == 1
# assert v[0] == 0
# compute variance in real values (center by computed mean)
# mean_moment_fn = moments.Monomial.factory(3, center=m[1])
mean_moment_fn = moments.Monomial.factory(3,
domain=true_domain,
ref_domain=true_domain,
safe_eval=False)
q_estimator = QuantityEstimate(sample_storage=storage,
sim_steps=self.step_range,
qspec=qspec,
time_id=time_id)
mm, vv = q_estimator.estimate_moments(mean_moment_fn)
# The first moment is in any case 1 and its variance is 0
assert np.isclose(mm[0], 1, atol=1e-10)
assert vv[0] == 0
# assert np.isclose(mm[1], 0, atol=1e-10)
# means.append([1, m[1], mm[2]])
# vars.append([0, v[1], vv[2]])
means.append(mm)
vars.append(vv)
# print("t = ", qspec.times[time_id], " means ", mm[1], mm[2])
# print("t = ", qspec.times[time_id], " vars ", vv[1], vv[2])
return np.array(means), np.array(vars)
def calculate_moments(self, sampler_list):
"""
Calculate _moments_fn through the mlmc.QuantityEstimate
:param sampler_list: List of samplers (mlmc.Sampler)
:return: None
"""
# Simple moment evaluation
for sampler in sampler_list:
moments_fn = self.set_moments(sampler._sample_storage)
q_estimator = QuantityEstimate(sample_storage=sampler._sample_storage, moments_fn=moments_fn,
sim_steps=self.step_range)
print("collected samples ", sampler._n_scheduled_samples)
means, vars = q_estimator.estimate_moments(moments_fn)
print("means ", means)
print("vars ", vars)
# The first moment is in any case 1 and its variance is 0
assert means[0] == 1
# assert np.isclose(means[1], 0, atol=1e-2)
assert vars[0] == 0
def set_moments(self, sample_storage):
n_moments = 5
true_domain = QuantityEstimate.estimate_domain(sample_storage, quantile=0.01)
return Legendre(n_moments, true_domain)
def run(self, renew=False):
np.random.seed(3)
n_moments = 5
failed_fraction = 0
# work_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '_test_tmp')
# if os.path.exists(work_dir):
# shutil.rmtree(work_dir)
# os.makedirs(work_dir)
distr = stats.norm()
step_range = [0.1, 0.001]
# User configure and create simulation instance
simulation_config = dict(distr=distr,
complexity=2,
nan_fraction=failed_fraction,
sim_method='_sample_fn')
#simulation_config = {"config_yaml": 'synth_sim_config.yaml'}
simulation_factory = SynthSimulation(simulation_config)
if self.clean:
os.remove(
os.path.join(self.work_dir,
"mlmc_{}.hdf5".format(len(step_range))))
sample_storage = SampleStorageHDF(file_path=os.path.join(
self.work_dir, "mlmc_{}.hdf5".format(len(step_range))),
append=self.append)
sampling_pool = OneProcessPool()
# Plan and compute samples
sampler = Sampler(sample_storage=sample_storage,
sampling_pool=sampling_pool,
sim_factory=simulation_factory,
step_range=step_range)
true_domain = distr.ppf([0.0001, 0.9999])
moments_fn = Legendre(n_moments, true_domain)
# moments_fn = Monomial(n_moments, true_domain)
if renew:
sampler.ask_sampling_pool_for_samples()
sampler.renew_failed_samples()
sampler.ask_sampling_pool_for_samples()
else:
sampler.set_initial_n_samples([12, 6])
# sampler.set_initial_n_samples([1000])
sampler.schedule_samples()
sampler.ask_sampling_pool_for_samples()
q_estimator = QuantityEstimate(sample_storage=sample_storage,
moments_fn=moments_fn,
sim_steps=step_range)
#
target_var = 1e-4
sleep = 0
add_coef = 0.1
# # @TODO: test
# # New estimation according to already finished samples
# variances, n_ops = q_estimator.estimate_diff_vars_regression(sampler._n_scheduled_samples)
# n_estimated = new_estimator.estimate_n_samples_for_target_variance(target_var, variances, n_ops,
# n_levels=sampler.n_levels)
#
# # Loop until number of estimated samples is greater than the number of scheduled samples
# while not sampler.process_adding_samples(n_estimated, sleep, add_coef):
# # New estimation according to already finished samples
# variances, n_ops = q_estimator.estimate_diff_vars_regression(sampler._n_scheduled_samples)
# n_estimated = new_estimator.estimate_n_samples_for_target_variance(target_var, variances, n_ops,
# n_levels=sampler.n_levels)
print("collected samples ", sampler._n_scheduled_samples)
means, vars = q_estimator.estimate_moments(moments_fn)
print("means ", means)
print("vars ", vars)
assert means[0] == 1
assert np.isclose(means[1], 0, atol=1e-2)
assert vars[0] == 0
def run(self, renew=False):
np.random.seed(3)
n_moments = 5
distr = stats.norm(loc=1, scale=2)
step_range = [0.01, 0.001]
# Set work dir
os.chdir(os.path.dirname(os.path.realpath(__file__)))
shutil.copyfile('synth_sim_config.yaml',
os.path.join(self.work_dir, 'synth_sim_config.yaml'))
simulation_config = {
"config_yaml": os.path.join(self.work_dir, 'synth_sim_config.yaml')
}
simulation_factory = SynthSimulationWorkspace(simulation_config)
if self.clean:
file_path = os.path.join(self.work_dir,
"mlmc_{}.hdf5".format(len(step_range)))
if os.path.exists(file_path):
os.remove(
os.path.join(self.work_dir,
"mlmc_{}.hdf5".format(len(step_range))))
sample_storage = SampleStorageHDF(file_path=os.path.join(
self.work_dir, "mlmc_{}.hdf5".format(len(step_range))),
append=self.append)
sampling_pool = SamplingPoolPBS(job_weight=20000000,
work_dir=self.work_dir,
clean=self.clean)
pbs_config = dict(
n_cores=1,
n_nodes=1,
select_flags=['cgroups=cpuacct'],
mem='128mb',
queue='charon_2h',
home_dir='/storage/liberec3-tul/home/martin_spetlik/',
pbs_process_file_dir=
'/auto/liberec3-tul/home/martin_spetlik/MLMC_new_design/src/mlmc',
python='python3',
env_setting=[
'cd {work_dir}', 'module load python36-modules-gcc',
'source env/bin/activate',
'pip3 install /storage/liberec3-tul/home/martin_spetlik/MLMC_new_design',
'module use /storage/praha1/home/jan-hybs/modules',
'module load python36-modules-gcc', 'module list'
])
sampling_pool.pbs_common_setting(flow_3=True, **pbs_config)
# Plan and compute samples
sampler = Sampler(sample_storage=sample_storage,
sampling_pool=sampling_pool,
sim_factory=simulation_factory,
step_range=step_range)
true_domain = distr.ppf([0.0001, 0.9999])
moments_fn = Legendre(n_moments, true_domain)
if renew:
sampler.ask_sampling_pool_for_samples()
sampler.renew_failed_samples()
sampler.ask_sampling_pool_for_samples()
else:
sampler.set_initial_n_samples([12, 6])
# sampler.set_initial_n_samples([1000])
sampler.schedule_samples()
sampler.ask_sampling_pool_for_samples()
q_estimator = QuantityEstimate(sample_storage=sample_storage,
moments_fn=moments_fn,
sim_steps=step_range)
# target_var = 1e-3
# sleep = 0
# add_coef = 0.1
#
# # @TODO: test
# # New estimation according to already finished samples
# variances, n_ops = q_estimator.estimate_diff_vars_regression(sampler._n_scheduled_samples)
# n_estimated = new_estimator.estimate_n_samples_for_target_variance(target_var, variances, n_ops,
# n_levels=sampler.n_levels)
# # Loop until number of estimated samples is greater than the number of scheduled samples
# while not sampler.process_adding_samples(n_estimated, sleep, add_coef):
# # New estimation according to already finished samples
# variances, n_ops = q_estimator.estimate_diff_vars_regression(sampler._n_scheduled_samples)
# n_estimated = new_estimator.estimate_n_samples_for_target_variance(target_var, variances, n_ops,
# n_levels=sampler.n_levels)
# print("collected samples ", sampler._n_created_samples)
means, vars = q_estimator.estimate_moments(moments_fn)
print("means ", means)
print("vars ", vars)
def multiproces_sampler_test():
np.random.seed(3)
n_moments = 5
failed_fraction = 0.1
distr = stats.norm(loc=1, scale=2)
step_range = [[0.01], [0.001], [0.0001]]
# Create simulation instance
simulation_config = dict(distr=distr,
complexity=2,
nan_fraction=failed_fraction,
sim_method='_sample_fn')
simulation_factory = SynthSimulation(simulation_config)
sample_storage = Memory()
sampling_pool = ProcessPool(4)
# Plan and compute samples
sampler = Sampler(sample_storage=sample_storage,
sampling_pool=sampling_pool,
sim_factory=simulation_factory,
level_parameters=step_range)
true_domain = distr.ppf([0.0001, 0.9999])
moments_fn = Legendre(n_moments, true_domain)
sampler.set_initial_n_samples()
#sampler.set_initial_n_samples([1000])
sampler.schedule_samples()
sampler.ask_sampling_pool_for_samples()
q_estimator = QuantityEstimate(sample_storage=sample_storage,
moments_fn=moments_fn,
sim_steps=step_range)
#
target_var = 1e-4
sleep = 0
add_coef = 0.1
# # @TODO: test
# # New estimation according to already finished samples
# variances, n_ops = q_estimator.estimate_diff_vars_regression(sampler._n_scheduled_samples)
# n_estimated = new_estimator.estimate_n_samples_for_target_variance(target_var, variances, n_ops,
# n_levels=sampler.n_levels)
#
# # Loop until number of estimated samples is greater than the number of scheduled samples
# while not sampler.process_adding_samples(n_estimated, sleep, add_coef):
# # New estimation according to already finished samples
# variances, n_ops = q_estimator.estimate_diff_vars_regression(sampler._n_scheduled_samples)
# n_estimated = new_estimator.estimate_n_samples_for_target_variance(target_var, variances, n_ops,
# n_levels=sampler.n_levels)
#
# print("n estimated ", n_estimated)
print("collected samples ", sampler._n_scheduled_samples)
means, vars = q_estimator.estimate_moments(moments_fn)
print("means ", means)
print("vars ", vars)
assert means[0] == 1
assert np.isclose(means[1], 0, atol=5 * 1e-2)
assert vars[0] == 0
sampler.schedule_samples()
sampler.ask_sampling_pool_for_samples()
storage = sampler.sample_storage
results = storage.sample_pairs()
def multiprocess_test():
np.random.seed(3)
n_moments = 5
distr = stats.norm(loc=1, scale=2)
step_range = [0.01, 0.001] #, 0.001, 0.0001]
os.chdir(os.path.dirname(os.path.realpath(__file__)))
work_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)),
'_test_tmp')
if os.path.exists(work_dir):
shutil.rmtree(work_dir)
os.makedirs(work_dir)
shutil.copyfile('synth_sim_config.yaml',
os.path.join(work_dir, 'synth_sim_config.yaml'))
simulation_config = {
"config_yaml": os.path.join(work_dir, 'synth_sim_config.yaml')
}
simulation_factory = SynthSimulationWorkspace(simulation_config)
sample_storage = Memory()
sampling_pool = ProcessPool(4, work_dir=work_dir)
# Plan and compute samples
sampler = Sampler(sample_storage=sample_storage,
sampling_pool=sampling_pool,
sim_factory=simulation_factory,
step_range=step_range)
true_domain = distr.ppf([0.0001, 0.9999])
moments_fn = Legendre(n_moments, true_domain)
sampler.set_initial_n_samples()
#sampler.set_initial_n_samples([1000])
sampler.schedule_samples()
sampler.ask_sampling_pool_for_samples()
q_estimator = QuantityEstimate(sample_storage=sample_storage,
moments_fn=moments_fn,
sim_steps=step_range)
target_var = 1e-4
sleep = 0
add_coef = 0.1
# # @TODO: test
# # New estimation according to already finished samples
# variances, n_ops = q_estimator.estimate_diff_vars_regression(sampler._n_scheduled_samples)
# n_estimated = new_estimator.estimate_n_samples_for_target_variance(target_var, variances, n_ops,
# n_levels=sampler.n_levels)
# # Loop until number of estimated samples is greater than the number of scheduled samples
# while not sampler.process_adding_samples(n_estimated, sleep, add_coef):
# # New estimation according to already finished samples
# variances, n_ops = q_estimator.estimate_diff_vars_regression(sampler._n_scheduled_samples)
# n_estimated = new_estimator.estimate_n_samples_for_target_variance(target_var, variances, n_ops,
# n_levels=sampler.n_levels)
print("collected samples ", sampler._n_scheduled_samples)
means, vars = q_estimator.estimate_moments(moments_fn)
print("means ", means)
print("vars ", vars)
assert means[0] == 1
assert np.isclose(means[1], 0, atol=1e-2)
assert vars[0] == 0
sampler.schedule_samples()
sampler.ask_sampling_pool_for_samples()
storage = sampler.sample_storage
results = storage.sample_pairs()