def set_moments(self, n_moments, log=False):
"""
Create moments function instance
:param n_moments: int, number of moments
:param log: bool, If true then apply log transform
:return:
"""
self.moments_fn = Legendre(n_moments,
self.domain,
safe_eval=True,
log=log)
return self.moments_fn
def thread_test():
np.random.seed(3)
n_moments = 5
distr = stats.norm(loc=1, scale=2)
step_range = [0.01, 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 = ThreadPool(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()
sampler.target_var_adding_samples(1e-4, moments_fn, sleep=20)
print("collected samples ", sampler._n_created_samples)
means, vars = sampler.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()
def test_mlmc(test_case):
np.random.seed(1234)
n_moments = 5
step_range = [[0.1], [0.001]]
simulation_factory, sample_storage, sampling_pool = test_case
if simulation_factory.need_workspace:
os.chdir(os.path.dirname(os.path.realpath(__file__)))
shutil.copyfile('synth_sim_config.yaml', os.path.join(work_dir, 'synth_sim_config.yaml'))
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)
# moments_fn = Monomial(n_moments, true_domain)
sampler.set_initial_n_samples([10, 10])
# sampler.set_initial_n_samples([10000])
sampler.schedule_samples()
sampler.ask_sampling_pool_for_samples()
target_var = 1e-3
sleep = 0
add_coef = 0.1
quantity = make_root_quantity(sample_storage, q_specs=simulation_factory.result_format())
length = quantity['length']
time = length[1]
location = time['10']
value_quantity = location[0]
estimator = mlmc.estimator.Estimate(value_quantity, sample_storage, moments_fn)
# New estimation according to already finished samples
variances, n_ops = estimator.estimate_diff_vars_regression(sampler._n_scheduled_samples)
n_estimated = mlmc.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 = estimator.estimate_diff_vars_regression(sampler._n_scheduled_samples)
n_estimated = mlmc.estimator.estimate_n_samples_for_target_variance(target_var, variances, n_ops,
n_levels=sampler.n_levels)
means, vars = estimator.estimate_moments(moments_fn)
assert means[0] == 1
assert vars[0] == 0
def test_sampling_pools(sampling_pool, simulation_factory):
n_moments = 5
np.random.seed(123)
t.sleep(5)
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)
if simulation_factory.need_workspace:
os.chdir(os.path.dirname(os.path.realpath(__file__)))
shutil.copyfile('synth_sim_config_test.yaml',
os.path.join(work_dir, 'synth_sim_config.yaml'))
sample_storage = SampleStorageHDF(file_path=os.path.join(
work_dir, "mlmc_{}.hdf5".format(len(step_range))))
# 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([10, 10, 10])
sampler.schedule_samples()
sampler.ask_sampling_pool_for_samples()
quantity = mlmc.quantity.make_root_quantity(
storage=sample_storage, q_specs=sample_storage.load_result_format())
length = quantity['length']
time = length[1]
location = time['10']
value_quantity = location[0]
estimator = Estimate(quantity=value_quantity,
sample_storage=sample_storage,
moments_fn=moments_fn)
means, vars = estimator.estimate_moments(moments_fn)
assert means[0] == 1
assert vars[0] == 0
assert np.allclose(np.array(ref_means), np.array(means), atol=1e-5)
assert np.allclose(np.array(ref_vars), np.array(ref_vars), atol=1e-5)
if sampling_pool._debug:
assert 'output' in next(os.walk(work_dir))[1]
def process(self):
sample_storage = SampleStorageHDF(file_path=os.path.join(
self.work_dir, "mlmc_{}.hdf5".format(self.n_levels)))
sample_storage.chunk_size = 1e8
result_format = sample_storage.load_result_format()
root_quantity = make_root_quantity(sample_storage, result_format)
conductivity = root_quantity['conductivity']
time = conductivity[1] # times: [1]
location = time['0'] # locations: ['0']
q_value = location[0, 0]
# @TODO: How to estimate true_domain?
quantile = 0.001
true_domain = mlmc.estimator.Estimate.estimate_domain(
q_value, sample_storage, quantile=quantile)
moments_fn = Legendre(self.n_moments, true_domain)
estimator = mlmc.estimator.Estimate(quantity=q_value,
sample_storage=sample_storage,
moments_fn=moments_fn)
means, vars = estimator.estimate_moments(moments_fn)
moments_quantity = moments(root_quantity,
moments_fn=moments_fn,
mom_at_bottom=True)
moments_mean = estimate_mean(moments_quantity)
conductivity_mean = moments_mean['conductivity']
time_mean = conductivity_mean[1] # times: [1]
location_mean = time_mean['0'] # locations: ['0']
values_mean = location_mean[0] # result shape: (1,)
value_mean = values_mean[0]
assert value_mean.mean == 1
# true_domain = [-10, 10] # keep all values on the original domain
# central_moments = Monomial(self.n_moments, true_domain, ref_domain=true_domain, mean=means())
# central_moments_quantity = moments(root_quantity, moments_fn=central_moments, mom_at_bottom=True)
# central_moments_mean = estimate_mean(central_moments_quantity)
#estimator.sub_subselect(sample_vector=[10000])
#self.process_target_var(estimator)
self.construct_density(estimator, tol=1e-8)
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 test_sampler_pbs(work_dir, clean=False, debug=False):
np.random.seed(3)
n_moments = 5
distr = stats.norm(loc=1, scale=2)
step_range = [0.5, 0.01]
n_levels = 5
# if clean:
# if os.path.isdir(work_dir):
# shutil.rmtree(work_dir, ignore_errors=True)
os.makedirs(work_dir, mode=0o775, exist_ok=True)
assert step_range[0] > step_range[1]
level_parameters = []
for i_level in range(n_levels):
if n_levels == 1:
level_param = 1
else:
level_param = i_level / (n_levels - 1)
level_parameters.append(
[step_range[0]**(1 - level_param) * step_range[1]**level_param])
failed_fraction = 0
simulation_config = dict(distr='norm',
complexity=2,
nan_fraction=failed_fraction,
sim_method='_sample_fn')
with open(os.path.join(work_dir, 'synth_sim_config.yaml'), "w") as file:
yaml.dump(simulation_config, file, default_flow_style=False)
simulation_config = {
"config_yaml": os.path.join(work_dir, 'synth_sim_config.yaml')
}
simulation_factory = SynthSimulationWorkspace(simulation_config)
if clean and os.path.exists(
os.path.join(work_dir, "mlmc_{}.hdf5".format(len(step_range)))):
os.remove(
os.path.join(work_dir, "mlmc_{}.hdf5".format(len(step_range))))
if clean and os.path.exists(os.path.join(work_dir, "output")):
shutil.rmtree(os.path.join(work_dir, "output"), ignore_errors=True)
sample_storage = SampleStorageHDF(file_path=os.path.join(
work_dir, "mlmc_{}.hdf5".format(len(step_range))))
sampling_pool = SamplingPoolPBS(work_dir=work_dir, clean=clean)
#sampling_pool = OneProcessPool()
shutil.copyfile(
os.path.join(work_dir, 'synth_sim_config.yaml'),
os.path.join(sampling_pool._output_dir, 'synth_sim_config.yaml'))
pbs_config = dict(
n_cores=1,
n_nodes=1,
select_flags=['cgroups=cpuacct'],
mem='2Gb',
queue='charon',
pbs_name='flow123d',
walltime='72:00:00',
optional_pbs_requests=[], # e.g. ['#PBS -m ae', ...]
home_dir='/auto/liberec3-tul/home/martin_spetlik/',
python='python3',
env_setting=[
'cd $MLMC_WORKDIR',
'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 load flow123d',
'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,
level_parameters=level_parameters)
true_domain = distr.ppf([0.0001, 0.9999])
moments_fn = Legendre(n_moments, true_domain)
sampler.set_initial_n_samples([1e7, 5e6, 1e6, 5e5, 1e4])
#sampler.set_initial_n_samples([1e1, 1e1, 1e1, 1e1, 1e1])
#sampler.set_initial_n_samples([4, 4, 4, 4, 4])
sampler.schedule_samples()
n_running = sampler.ask_sampling_pool_for_samples()
quantity = mlmc.quantity.make_root_quantity(
storage=sample_storage, q_specs=sample_storage.load_result_format())
length = quantity['length']
time = length[1]
location = time['10']
value_quantity = location[0]
estimator = Estimate(quantity=value_quantity,
sample_storage=sample_storage,
moments_fn=moments_fn)
# 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 = estimator.estimate_moments(moments_fn)
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()