def test_load_results(self):
# test for 1d
# test for 2d
# test for 3d
nr_experiments = 10000
experiments = pd.DataFrame(index=np.arange(nr_experiments),
columns={
'x': np.float,
'y': np.float
})
experiments['x'] = np.random.rand(nr_experiments)
experiments['y'] = np.random.rand(nr_experiments)
outcome_a = np.zeros((nr_experiments, 1))
results = (experiments, {'a': outcome_a})
save_results(results, '../data/test.tar.gz')
loaded_experiments, outcomes = load_results('../data/test.tar.gz')
self.assertTrue(np.all(np.allclose(outcomes['a'], outcome_a)))
self.assertTrue(
np.all(np.allclose(experiments['x'], loaded_experiments['x'])))
self.assertTrue(
np.all(np.allclose(experiments['y'], loaded_experiments['y'])))
os.remove('../data/test.tar.gz')
nr_experiments = 1000
nr_timesteps = 100
nr_replications = 10
experiments = pd.DataFrame(index=np.arange(nr_experiments),
columns={
'x': np.float,
'y': np.float
})
experiments['x'] = np.random.rand(nr_experiments)
experiments['y'] = np.random.rand(nr_experiments)
outcome_a = np.zeros((nr_experiments, nr_timesteps, nr_replications))
results = (experiments, {'a': outcome_a})
save_results(results, '../data/test.tar.gz')
loaded_experiments, outcomes = load_results('../data/test.tar.gz')
os.remove('../data/test.tar.gz')
self.assertTrue(np.all(np.allclose(outcomes['a'], outcome_a)))
self.assertTrue(
np.all(np.allclose(experiments['x'], loaded_experiments['x'])))
self.assertTrue(
np.all(np.allclose(experiments['y'], loaded_experiments['y'])))
def test_load_results(self):
# test for 1d
# test for 2d
# test for 3d
nr_experiments = 10000
experiments = np.recarray((nr_experiments, ),
dtype=[('x', np.float), ('y', np.float)])
experiments['x'] = np.random.rand(nr_experiments)
experiments['y'] = np.random.rand(nr_experiments)
outcome_a = np.zeros((nr_experiments, 1))
results = (experiments, {'a': outcome_a})
save_results(results, '../data/test.tar.gz')
loaded_experiments, outcomes = load_results('../data/test.tar.gz')
self.assertTrue(np.all(np.allclose(outcomes['a'], outcome_a)))
self.assertTrue(
np.all(np.allclose(experiments['x'], loaded_experiments['x'])))
self.assertTrue(
np.all(np.allclose(experiments['y'], loaded_experiments['y'])))
os.remove('../data/test.tar.gz')
nr_experiments = 1000
nr_timesteps = 100
nr_replications = 10
experiments = np.recarray((nr_experiments, ),
dtype=[('x', np.float), ('y', np.float)])
experiments['x'] = np.random.rand(nr_experiments)
experiments['y'] = np.random.rand(nr_experiments)
outcome_a = np.zeros((nr_experiments, nr_timesteps, nr_replications))
results = (experiments, {'a': outcome_a})
save_results(results, '../data/test.tar.gz')
loaded_experiments, outcomes = load_results('../data/test.tar.gz')
os.remove('../data/test.tar.gz')
self.assertTrue(np.all(np.allclose(outcomes['a'], outcome_a)))
self.assertTrue(
np.all(np.allclose(experiments['x'], loaded_experiments['x'])))
self.assertTrue(
np.all(np.allclose(experiments['y'], loaded_experiments['y'])))
def test_load_results(self):
# test for 1d
# test for 2d
# test for 3d
nr_experiments = 10000
experiments = pd.DataFrame(index=np.arange(nr_experiments),
columns={'x':np.float,
'y': np.float})
experiments['x'] = np.random.rand(nr_experiments)
experiments['y'] = np.random.rand(nr_experiments)
outcome_a = np.zeros((nr_experiments,1))
results = (experiments, {'a': outcome_a})
save_results(results, '../data/test.tar.gz')
loaded_experiments, outcomes = load_results('../data/test.tar.gz')
self.assertTrue(np.all(np.allclose(outcomes['a'],outcome_a)))
self.assertTrue(np.all(np.allclose(experiments['x'],loaded_experiments['x'])))
self.assertTrue(np.all(np.allclose(experiments['y'],loaded_experiments['y'])))
os.remove('../data/test.tar.gz')
nr_experiments = 1000
nr_timesteps = 100
nr_replications = 10
experiments = pd.DataFrame(index=np.arange(nr_experiments),
columns={'x':np.float,
'y': np.float})
experiments['x'] = np.random.rand(nr_experiments)
experiments['y'] = np.random.rand(nr_experiments)
outcome_a = np.zeros((nr_experiments,nr_timesteps,nr_replications))
results = (experiments, {'a': outcome_a})
save_results(results, '../data/test.tar.gz')
loaded_experiments, outcomes = load_results('../data/test.tar.gz')
os.remove('../data/test.tar.gz')
self.assertTrue(np.all(np.allclose(outcomes['a'],outcome_a)))
self.assertTrue(np.all(np.allclose(experiments['x'],loaded_experiments['x'])))
self.assertTrue(np.all(np.allclose(experiments['y'],loaded_experiments['y'])))
def test_save_results(self):
# test for 1d
# test for 2d
# test for 3d
# test for very large
nr_experiments = 10000
experiments = np.recarray((nr_experiments,),
dtype=[('x', float), ('y', float)])
outcome_a = np.random.rand(nr_experiments,1)
results = (experiments, {'a': outcome_a})
fn = u'../data/test.tar.gz'
save_results(results, fn)
os.remove(fn)
# ema_logging.info('1d saved successfully')
nr_experiments = 10000
nr_timesteps = 100
experiments = np.recarray((nr_experiments,),
dtype=[('x', float), ('y', float)])
outcome_a = np.zeros((nr_experiments,nr_timesteps))
results = (experiments, {'a': outcome_a})
save_results(results, fn)
os.remove(fn)
# ema_logging.info('2d saved successfully')
nr_experiments = 10000
nr_timesteps = 100
nr_replications = 10
experiments = np.recarray((nr_experiments,),
dtype=[('x', float), ('y', float)])
outcome_a = np.zeros((nr_experiments,nr_timesteps,nr_replications))
results = (experiments, {'a': outcome_a})
save_results(results, fn)
os.remove(fn)
# ema_logging.info('3d saved successfully')
nr_experiments = 500000
nr_timesteps = 100
experiments = np.recarray((nr_experiments,),
dtype=[('x', float), ('y', float)])
outcome_a = np.zeros((nr_experiments,nr_timesteps))
results = (experiments, {'a': outcome_a})
save_results(results, fn)
os.remove(fn)
def test_load_results(self):
# test for 1d
# test for 2d
# test for 3d
nr_experiments = 10000
experiments = np.recarray((nr_experiments, ),
dtype=[('x', float), ('y', float)])
outcome_a = np.zeros((nr_experiments, 1))
results = (experiments, {'a': outcome_a})
save_results(results, u'../data/test.tar.gz')
experiments, outcomes = load_results(u'../data/test.tar.gz')
logical = np.allclose(outcomes['a'], outcome_a)
os.remove('../data/test.tar.gz')
# if logical:
# ema_logging.info('1d loaded successfully')
nr_experiments = 1000
nr_timesteps = 100
nr_replications = 10
experiments = np.recarray((nr_experiments, ),
dtype=[('x', float), ('y', float)])
outcome_a = np.zeros((nr_experiments, nr_timesteps, nr_replications))
results = (experiments, {'a': outcome_a})
save_results(results, '../data/test.tar.gz')
experiments, outcomes = load_results('../data/test.tar.gz')
logical = np.allclose(outcomes['a'], outcome_a)
os.remove('../data/test.tar.gz')
def test_load_results(self):
# test for 1d
# test for 2d
# test for 3d
nr_experiments = 10000
experiments = np.recarray((nr_experiments,),
dtype=[('x', float), ('y', float)])
outcome_a = np.zeros((nr_experiments,1))
results = (experiments, {'a': outcome_a})
save_results(results, u'../data/test.tar.gz')
experiments, outcomes = load_results(u'../data/test.tar.gz')
logical = np.allclose(outcomes['a'],outcome_a)
os.remove('../data/test.tar.gz')
# if logical:
# ema_logging.info('1d loaded successfully')
nr_experiments = 1000
nr_timesteps = 100
nr_replications = 10
experiments = np.recarray((nr_experiments,),
dtype=[('x', float), ('y', float)])
outcome_a = np.zeros((nr_experiments,nr_timesteps,nr_replications))
results = (experiments, {'a': outcome_a})
save_results(results, u'../data/test.tar.gz')
experiments, outcomes = load_results(u'../data/test.tar.gz')
logical = np.allclose(outcomes['a'],outcome_a)
os.remove('../data/test.tar.gz')
def test_save_results(self):
# test for 1d
# test for 2d
# test for 3d
# test for very large
nr_experiments = 10000
experiments = pd.DataFrame(index=np.arange(nr_experiments),
columns={
'x': np.float,
'y': np.float
})
outcome_a = np.random.rand(nr_experiments, 1)
results = (experiments, {'a': outcome_a})
fn = u'../data/test.tar.gz'
save_results(results, fn)
os.remove(fn)
# ema_logging.info('1d saved successfully')
nr_experiments = 10000
nr_timesteps = 100
experiments = pd.DataFrame(index=np.arange(nr_experiments),
columns={
'x': np.float,
'y': np.float
})
outcome_a = np.zeros((nr_experiments, nr_timesteps))
results = (experiments, {'a': outcome_a})
save_results(results, fn)
os.remove(fn)
# ema_logging.info('2d saved successfully')
nr_experiments = 10000
nr_timesteps = 100
nr_replications = 10
experiments = pd.DataFrame(index=np.arange(nr_experiments),
columns={
'x': np.float,
'y': np.float
})
outcome_a = np.zeros((nr_experiments, nr_timesteps, nr_replications))
results = (experiments, {'a': outcome_a})
save_results(results, fn)
os.remove(fn)
def test_save_results(self):
# test for 1d
# test for 2d
# test for 3d
# test for very large
nr_experiments = 10000
experiments = pd.DataFrame(index=np.arange(nr_experiments),
columns={'x':np.float,
'y': np.float})
outcome_a = np.random.rand(nr_experiments,1)
results = (experiments, {'a': outcome_a})
fn = u'../data/test.tar.gz'
save_results(results, fn)
os.remove(fn)
# ema_logging.info('1d saved successfully')
nr_experiments = 10000
nr_timesteps = 100
experiments = pd.DataFrame(index=np.arange(nr_experiments),
columns={'x':np.float,
'y': np.float})
outcome_a = np.zeros((nr_experiments,nr_timesteps))
results = (experiments, {'a': outcome_a})
save_results(results, fn)
os.remove(fn)
# ema_logging.info('2d saved successfully')
nr_experiments = 10000
nr_timesteps = 100
nr_replications = 10
experiments = pd.DataFrame(index=np.arange(nr_experiments),
columns={'x':np.float,
'y': np.float})
outcome_a = np.zeros((nr_experiments,nr_timesteps,nr_replications))
results = (experiments, {'a': outcome_a})
save_results(results, fn)
os.remove(fn)
def test_save_results(self):
# test for 1d
# test for 2d
# test for 3d
# test for very large
nr_experiments = 10000
experiments = np.recarray((nr_experiments, ),
dtype=[('x', float), ('y', float)])
outcome_a = np.random.rand(nr_experiments, 1)
results = (experiments, {'a': outcome_a})
fn = u'../data/test.tar.gz'
save_results(results, fn)
os.remove(fn)
# ema_logging.info('1d saved successfully')
nr_experiments = 10000
nr_timesteps = 100
experiments = np.recarray((nr_experiments, ),
dtype=[('x', float), ('y', float)])
outcome_a = np.zeros((nr_experiments, nr_timesteps))
results = (experiments, {'a': outcome_a})
save_results(results, fn)
os.remove(fn)
# ema_logging.info('2d saved successfully')
nr_experiments = 10000
nr_timesteps = 100
nr_replications = 10
experiments = np.recarray((nr_experiments, ),
dtype=[('x', float), ('y', float)])
outcome_a = np.zeros((nr_experiments, nr_timesteps, nr_replications))
results = (experiments, {'a': outcome_a})
save_results(results, fn)
os.remove(fn)
model.uncertainties = uncertainties
model.outcomes = [ArrayOutcome('stedin_capacity'),
ArrayOutcome('stedin_load'),
ArrayOutcome('tennet_capacity'),
ArrayOutcome('tennet_load'),
ArrayOutcome('gasunie_capacity'),
ArrayOutcome('investments'),
ArrayOutcome('stedin capex'),
ArrayOutcome('tennet capex'),
ArrayOutcome('gasunie capex'),
ArrayOutcome('collaborative capex'),
ArrayOutcome('h2_import'),
ArrayOutcome('stedin_lost'),
ArrayOutcome('first_failure'),
ArrayOutcome('missed_over_time')
]
_logger.info(f"{len(uncertainties)} uncertainties defined")
_logger.info(f"{len(model.replications)} replications defined")
n_scenarios = 2500
print(datetime.datetime.now())
# with SequentialEvaluator(model) as evaluator:
with MultiprocessingEvaluator(model, n_processes=56) as evaluator:
results = evaluator.perform_experiments(n_scenarios, uncertainty_sampling=MC)
save_results(results, f'./results/{n_scenarios}_scenarios_{len(model.replications)} replications_{datetime.datetime.now()}_MC.tar.gz')
print(datetime.datetime.now())
RealParameter("ShipTbl3", -0.1, 0.1),
RealParameter("collaboration", 1, 1.6),
CategoricalParameter("land use scenarios", [
"NoChange", "moreNature", "Deurbanization", "sustainableGrowth",
"urbanizationDeurbanization", "urbanizationLargeAndFast",
"urbanizationLargeSteady"
],
pff=True)
]
waas_model.outcomes = [
ScalarOutcome("Flood damage (Milj. Euro)"),
ScalarOutcome("Number of casualties"),
ScalarOutcome("Costs"),
ScalarOutcome("Timing")
]
n_scenarios = 500
policies = [
Policy(kwargs['name'], **kwargs['params']) for kwargs in policies
]
with MultiprocessingEvaluator(waas_model) as evaluator:
# with SequentialEvaluator(waas_model) as evaluator:
results = perform_experiments(waas_model,
n_scenarios,
policies,
evaluator=evaluator)
save_results(results, './data/partial factorial over pathways.tar.gz')
variable_name='A.5_Expected Annual Damage', function=A5_Total_Costs),
ScalarOutcome('RfR total costs', kind=MINIMIZE, variable_name='RfR Total Costs', function=RfR_Total_Costs),
ScalarOutcome('Evacuation costs', kind=MINIMIZE, variable_name='Expected Evacuation Costs', function=Expected_Evacuation_Costs)
]
constraints = [Constraint("ConstrA.1_Expected Annual Damage", outcome_names="A.1_Expected Annual Damage",
function=lambda x:max(0, x-40000000)),
Constraint("ConstrA.1_Expected Number of Deaths", outcome_names="A.1_Expected Number of Deaths",
function=lambda x:max(0, x-1))
]
# Record the run time
start = time.time()
# We assume we needed to put 17x 0 and 17x 1 for convergence, because we have 17 outcomes in Robustness_functions?
# In assignment 10, there were 4 outcomes, and also 4x 0 and 4x 1 here in the convergence part
convergence = [HyperVolume(minimum=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], maximum=[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]),
EpsilonProgress()]
nfe = 200 # int(1e4)
# Run it
if __name__ == '__main__':
with MultiprocessingEvaluator(dike_model, n_processes=7) as evaluator:
results = evaluator.robust_optimize(robustness_functions, scenarios,
nfe=nfe, convergence=convergence, constraints=constraints,
epsilons=[0.05,]*len(robustness_functions))
utilities.save_results(results, 'Outcomes/MOROrijkswaterstaatConstraints.tar.gz')
end = time.time()
print('Total run time:{} min'.format((end - start)/60))
