def maxmin_optimize():
ema_logging.log_to_stderr(ema_logging.INFO)
model = TestModel("", 'simpleModel') #instantiate the model
ensemble = ModelEnsemble() #instantiate an ensemble
ensemble.set_model_structure(model) #set the model on the ensemble
ensemble.parallel = True
ensemble.processes = 12
def obj_function1(outcomes):
return outcomes['y']
policy_levers = { "L1": (0,1),
"L2": (0,1)}
results = ensemble.perform_maximin_optimization(obj_function1 = obj_function1,
policy_levers = policy_levers,
minimax1='minimize',
nrOfGenerations1=50,
nrOfPopMembers1=200,
minimax2 = "maximize",
nrOfGenerations2 = 50,
nrOfPopMembers2 = 100,
)
graph_errorbars_raw(results['stats'])
plt.show()
def transition_test():
model = EnergyTrans(r"..\..\..\models\EnergyTrans", "fluCase")
ensemble = ModelEnsemble()
ensemble.set_model_structure(model)
ensemble.perform_experiments(cases=10, callback=HDF5Callback)
def flu_test():
model = FluModel(r"..\..\..\models\flu", "fluCase")
ensemble = ModelEnsemble()
ensemble.set_model_structure(model)
ensemble.perform_experiments(cases=10, callback=HDF5Callback)
def test_optimization():
ema_logging.log_to_stderr(ema_logging.INFO)
model = FluModel(r'..\data', "fluCase")
ensemble = ModelEnsemble()
ensemble.set_model_structure(model)
ensemble.parallel=True
# ensemble.processes = 12
stats, pop = ensemble.perform_outcome_optimization(obj_function = obj_function_multi,
reporting_interval=10,
weights=(MAXIMIZE, MAXIMIZE),
pop_size=100,
nr_of_generations=5,
crossover_rate=0.5,
mutation_rate=0.05)
res = stats.hall_of_fame.keys
x = [entry.values[0] for entry in res]
y = [entry.values[1] for entry in res]
print len(x), len(y)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.scatter(x,y)
ax.set_ylabel("deceased population")
ax.set_xlabel("infected fraction")
plt.show()
def test_inspect():
import inspect_test
model = FluModel(r'..\..\..\models\flu', "fluCase")
ensemble = ModelEnsemble()
ensemble.set_model_structure(model)
ensemble.perform_experiments(cases = 10,
callback=inspect_test.InspectCallback)
def perform_experiments():
ema_logging.log_to_stderr(level=ema_logging.INFO)
model = SalinizationModel(r"C:\workspace\EMA-workbench\models\salinization", "verzilting")
model.step = 4
ensemble = ModelEnsemble()
ensemble.set_model_structure(model)
ensemble.parallel = True
nr_of_experiments = 10000
results = ensemble.perform_experiments(nr_of_experiments)
return results
def test_save_results():
os.remove("test.h5")
nrOfExperiments = 10
fileName = "test.h5"
experimentName = "one_exp_test"
ensemble = ModelEnsemble()
ensemble.set_model_structure(FluModel(r"..\..\..\models\flu", "fluCase"))
ensemble.perform_experiments(
nrOfExperiments, callback=HDF5Callback, fileName=fileName, experimentName=experimentName
)
def test_running_lookup_uncertainties(self):
'''
This is the more comprehensive test, given that the lookup
uncertainty replaces itself with a bunch of other uncertainties, check
whether we can successfully run a set of experiments and get results
back. We assert that the uncertainties are correctly replaced by
analyzing the experiments array.
'''
model = LookupTestModel( r'../models/', 'lookupTestModel')
#model.step = 4 #reduce data to be stored
ensemble = ModelEnsemble()
ensemble.set_model_structure(model)
ensemble.perform_experiments(10)
def test_vensim_model(self):
#instantiate a model
wd = r'../models'
model = VensimExampleModel(wd, "simpleModel")
#instantiate an ensemble
ensemble = ModelEnsemble()
#set the model on the ensemble
ensemble.set_model_structure(model)
nr_runs = 10
experiments, outcomes = ensemble.perform_experiments(nr_runs)
self.assertEqual(experiments.shape[0], nr_runs)
self.assertIn('TIME', outcomes.keys())
self.assertIn(model.outcomes[0].name, outcomes.keys())
def test_optimization():
ema_logging.log_to_stderr(ema_logging.INFO)
model = FluModel(r'..\data', "fluCase")
ensemble = ModelEnsemble()
ensemble.set_model_structure(model)
ensemble.parallel=True
stats, pop = ensemble.perform_outcome_optimization(obj_function = obj_function_multi,
reporting_interval=100,
weights=(MAXIMIZE, MAXIMIZE),
pop_size=100,
nr_of_generations=20,
crossover_rate=0.5,
mutation_rate=0.05,
caching=False)
res = stats.hall_of_fame.keys
print len(stats.tried_solutions.values())
def test_tree():
log_to_stderr(level= INFO)
model = FluModel(r'..\..\models\flu', "fluCase")
ensemble = ModelEnsemble()
ensemble.parallel = True
ensemble.set_model_structure(model)
policies = [{'name': 'no policy',
'file': r'\FLUvensimV1basecase.vpm'},
{'name': 'static policy',
'file': r'\FLUvensimV1static.vpm'},
{'name': 'adaptive policy',
'file': r'\FLUvensimV1dynamic.vpm'}
]
ensemble.add_policies(policies)
results = ensemble.perform_experiments(10)
a_tree = tree(results, classify)
def outcome_optimize():
ema_logging.log_to_stderr(ema_logging.INFO)
model = TestModel("", 'simpleModel') #instantiate the model
ensemble = ModelEnsemble() #instantiate an ensemble
ensemble.set_model_structure(model) #set the model on the ensemble
policy = {"name": "test",
"L1": 1,
"L2": 1}
ensemble.add_policy(policy)
def obj_func(results):
return results['y']
results = ensemble.perform_outcome_optimization(obj_function=obj_func,
minimax = 'minimize',
nrOfGenerations = 1000,
nrOfPopMembers = 10)
graph_errorbars_raw(results['stats'])
plt.show()
def test_feature_selection():
log_to_stderr(level= INFO)
model = FluModel(r'..\..\models\flu', "fluCase")
ensemble = ModelEnsemble()
ensemble.parallel = True
ensemble.set_model_structure(model)
policies = [{'name': 'no policy',
'file': r'\FLUvensimV1basecase.vpm'},
{'name': 'static policy',
'file': r'\FLUvensimV1static.vpm'},
{'name': 'adaptive policy',
'file': r'\FLUvensimV1dynamic.vpm'}
]
ensemble.add_policies(policies)
results = ensemble.perform_experiments(5000)
results = feature_selection(results, classify)
for entry in results:
print entry[0] +"\t" + str(entry[1])
def robust_optimize():
ema_logging.log_to_stderr(ema_logging.INFO)
model = TestModel("", 'simpleModel') #instantiate the model
ensemble = ModelEnsemble() #instantiate an ensemble
ensemble.set_model_structure(model) #set the model on the ensemble
policy_levers = { "L1": (0,1),
"L2": (0,1)}
def obj_func(results):
return np.average(results['y'])
results = ensemble.perform_robust_optimization(cases=1000,
obj_function=obj_func,
policy_levers=policy_levers,
minimax='minimize',
nrOfGenerations=50,
nrOfPopMembers=20 )
graph_errorbars_raw(results['stats'])
plt.show()
def test_optimization():
ema_logging.log_to_stderr(ema_logging.INFO)
model = FluModel(r'../models', "fluCase")
ensemble = ModelEnsemble()
ensemble.set_model_structure(model)
ensemble.parallel=True
pop_size = 8
nr_of_generations = 10
eps = np.array([1e-3, 1e6])
stats, pop = ensemble.perform_outcome_optimization(obj_function = obj_function_multi,
algorithm=epsNSGA2,
reporting_interval=100,
weights=(MAXIMIZE, MAXIMIZE),
pop_size=pop_size,
nr_of_generations=nr_of_generations,
crossover_rate=0.8,
mutation_rate=0.05,
eps=eps)
fn = '../data/test optimization save.bz2'
if error:
raise CaseError("run not completed", case)
def obj_func(outcomes):
outcome = outcomes['total fraction new technologies']
zeros = np.zeros((outcome.shape[0], 1))
zeros[outcome[:,-1]>0.6] = 1
value = np.sum(zeros)/zeros.shape[0]
return value,
if __name__ == "__main__":
ema_logging.log_to_stderr(ema_logging.INFO)
model = EnergyTrans(r"..\data", "ESDMAElecTrans")
ensemble = ModelEnsemble()
ensemble.set_model_structure(model)
ensemble.parallel = True
policy_levers = {'Trigger subsidy T2': {'type':'range', 'values':(0,1)},
'Trigger subsidy T3': {'type':'range', 'values':(0,1)},
'Trigger subsidy T4': {'type':'range', 'values':(0,1)},
'Trigger addnewcom': {'type':'list', 'values':[0, 0.25, 0.5, 0.75, 1]}}
stats_callback, pop = ensemble.perform_robust_optimization(cases=10,
reporting_interval=100,
obj_function=obj_func,
policy_levers=policy_levers,
weights = (MAXIMIZE,),
nr_of_generations=100,
pop_size=10,
crossover_rate=0.5,
]
outcomes = [
Outcome("sheep", time=True),
Outcome("wolves", time=True),
Outcome("grass", time=True), # TODO patches not working in reporting
]
if __name__ == "__main__":
# turn on logging
ema_logging.log_to_stderr(ema_logging.INFO)
# instantiate a model
vensimModel = PredatorPrey(r"..\..\models\predatorPreyNetlogo", "simpleModel")
# instantiate an ensemble
ensemble = ModelEnsemble()
# set the model on the ensemble
ensemble.set_model_structure(vensimModel)
# run in parallel, if not set, FALSE is assumed
ensemble.parallel = True
# perform experiments
results = ensemble.perform_experiments(100)
plotting.lines(results, density=plotting.KDE)
plt.show()
r'D:\tbm-g367\workspace\EMA workbench\src\sandbox\sils\Models\Consecutive',
"scarcity")
model_location = r'D:\tbm-g367\workspace\EMA workbench\src\sandbox\sils\Models\Consecutive\Metals EMA.vpm'
elif loop_index == 0:
model = ScarcityModel(
r'D:\tbm-g367\workspace\EMA workbench\src\sandbox\sils\Models\Base',
"scarcity")
model_location = r'D:\tbm-g367\workspace\EMA workbench\src\sandbox\sils\Models\Base\Metals EMA.vpm'
else:
model = ScarcityModel(
r'D:\tbm-g367\workspace\EMA workbench\src\sandbox\sils\Models\Switches',
"scarcity")
model_location = r'D:\tbm-g367\workspace\EMA workbench\src\sandbox\sils\Models\Switches\Metals EMA.vpm'
ensemble = ModelEnsemble()
ensemble.set_model_structure(model)
serie = run_interval(model_location, loop_index, interval,
'relative market price', unique_edges, indCons,
double_list, uncertain_names,
uncertain_values[beh_no])
interval_series.append(serie)
print(interval_series)
base = behaviour_int[beh_no][interval[0]:interval[1]]
print len(base), len(interval_series[0])
distances, dominant = dominance_distance(behaviour_int[beh_no],
interval_series)
print distances, dominant
# x = range(0,len(interval_series))
outcomes = [
Outcome('CumulativeGHGreduction', time=True),
]
if __name__ == "__main__":
#turn on logging
ema_logging.log_to_stderr(ema_logging.INFO)
#instantiate a model
vensimModel = EVO(r"./models", "simpleModel")
#instantiate an ensemble
ensemble = ModelEnsemble()
#set the model on the ensemble
ensemble.set_model_structure(vensimModel)
#
# run in parallel, if not set, FALSE is assumed
ensemble.parallel = True
cases = [{} for _ in range(1000)]
#perform experiments
results = ensemble.perform_experiments(cases, reporting_interval=100)
save_results(
results,
r'.\data\EMA results ModelSebastiaanGreeven 1000 exp Stoch Test.tar.gz'
)
class SimplePythonModel(ModelStructureInterface):
"""
This class represents a simple example of how one can extent the basic
ModelStructureInterface in order to do EMA on a simple model coded in
Python directly
"""
# specify uncertainties
uncertainties = [
ParameterUncertainty((0.1, 10), "x1"),
ParameterUncertainty((-0.01, 0.01), "x2"),
ParameterUncertainty((-0.01, 0.01), "x3"),
]
# specify outcomes
outcomes = [Outcome("y")]
def model_init(self, policy, kwargs):
pass
def run_model(self, case):
"""Method for running an instantiated model structure """
self.output[self.outcomes[0].name] = case["x1"] * case["x2"] + case["x3"]
if __name__ == "__main__":
model = SimplePythonModel(None, "simpleModel") # instantiate the model
ensemble = ModelEnsemble() # instantiate an ensemble
ensemble.set_model_structure(model) # set the model on the ensemble
results = ensemble.perform_experiments(1000) # generate 1000 cases
susceptible_population_region_1 = susceptible_population_region_1_NEXT
susceptible_population_region_2 = susceptible_population_region_2_NEXT
immune_population_region_1 = immune_population_region_1_NEXT
immune_population_region_2 = immune_population_region_2_NEXT
deceased_population_region_1.append(deceased_population_region_1_NEXT)
deceased_population_region_2.append(deceased_population_region_2_NEXT)
#End of main code
return (runTime, deceased_population_region_1) #, Max_infected, Max_time)
if __name__ == "__main__":
import expWorkbench.ema_logging as logging
np.random.seed(150) #set the seed for replication purposes
logging.log_to_stderr(logging.INFO)
fluModel = MexicanFlu(None, "mexicanFluExample")
ensemble = ModelEnsemble()
ensemble.parallel = True
ensemble.set_model_structure(fluModel)
nr_experiments = 500
results = ensemble.perform_experiments(nr_experiments, reporting_interval=100)
lines(results, outcomes_to_show="deceased_population_region_1",
show_envelope=True, density=KDE, titles=None,
experiments_to_show=np.arange(0, nr_experiments, 10)
)
plt.show()
