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.
'''
if os.name != 'nt':
return
model = LookupTestModel( r'../models/', 'lookupTestModel')
#model.step = 4 #reduce data to be stored
ensemble = ModelEnsemble()
ensemble.model_structure = model
ensemble.perform_experiments(10)
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.
'''
if os.name != 'nt':
return
model = LookupTestModel(r'../models/', 'lookupTestModel')
#model.step = 4 #reduce data to be stored
ensemble = ModelEnsemble()
ensemble.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.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_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.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())
'''
Created on Mar 15, 2012
.. codeauthor:: jhkwakkel <j.h.kwakkel (at) tudelft (dot) nl>
'''
from analysis import clusterer
from util import ema_logging
from core import ModelEnsemble
from test.scarcity_example import ScarcityModel
if __name__ == "__main__":
ema_logging.log_to_stderr(ema_logging.INFO)
model = ScarcityModel(r'..\..\src\test', "fluCase")
ensemble = ModelEnsemble()
ensemble.set_model_structure(model)
ensemble.parallel = True
results = ensemble.perform_experiments(200)
clusterer.cluster(data=results,
outcome='relative market price',
distance='gonenc',
cMethod='maxclust',
cValue=5,
plotDendrogram=False)
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__':
ema_logging.log_to_stderr(ema_logging.INFO)
model = SimplePythonModel(None, 'simpleModel') #instantiate the model
ensemble = ModelEnsemble() #instantiate an ensemble
ensemble.parallel = True
ensemble.model_structure = model #set the model on the ensemble
results = ensemble.perform_experiments(1000) #run 1000 experiments
"susceptible to immune population delay time region 1"),
ParameterUncertainty((0.5,2),
"susceptible to immune population delay time region 2"),
ParameterUncertainty((0.01, 5),
"root contact rate region 1"),
ParameterUncertainty((0.01, 5),
"root contact ratio region 2"),
ParameterUncertainty((0, 0.15),
"infection ratio region 1"),
ParameterUncertainty((0, 0.15),
"infection rate region 2"),
ParameterUncertainty((10, 100),
"normal contact rate region 1"),
ParameterUncertainty((10, 200),
"normal contact rate region 2")]
if __name__ == "__main__":
ema_logging.log_to_stderr(ema_logging.INFO)
model = FluModel(r'./models/flu', "fluCase")
ensemble = ModelEnsemble()
ensemble.model_structure = model
ensemble.parallel = True #turn on parallel processing
nr_experiments = 1000
results = ensemble.perform_experiments(nr_experiments)
fh = r'./data/{} flu cases no policy.tar.gz'.format(nr_experiments)
save_results(results, fh)
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
fh = r"./models/predatorPreyNetlogo"
model = PredatorPrey(fh, "simpleModel")
#instantiate an ensemble
ensemble = ModelEnsemble()
#set the model on the ensemble
ensemble.model_structure = model
#run in parallel, if not set, FALSE is assumed
ensemble.parallel = True
#perform experiments
results = ensemble.perform_experiments(100, reporting_interval=1)
plotting.lines(results, density=plotting_util.KDE)
plt.show()
else:
atomicBehavior.append([last, steps])
last = entry
steps = 0
atomicBehavior.append([last, steps])
behavior = []
behavior.append(atomicBehavior.pop(0))
for entry in atomicBehavior:
if entry[0] != behavior[-1][0] and entry[1] >2:
behavior.append(entry)
elif entry[1] <2:
continue
else:
behavior[-1][1] =+ entry[1]
behavior = [entry[0] for entry in behavior]
return behavior
if __name__ == "__main__":
ema_logging.log_to_stderr(ema_logging.INFO)
model = ScarcityModel(r'..\data', "scarcity")
ensemble = ModelEnsemble()
ensemble.set_model_structure(model)
ensemble.parallel = True
results = ensemble.perform_experiments(100)
# determineBehavior(results)
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__":
np.random.seed(150) #set the seed for replication purposes
ema_logging.log_to_stderr(ema_logging.INFO)
fluModel = MexicanFlu(None, "mexicanFluExample")
ensemble = ModelEnsemble()
ensemble.parallel = True
ensemble.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()
#specify outcomes
outcomes = [Outcome('a', time=True)]
#specify your uncertainties
uncertainties = [
ParameterUncertainty((0, 2.5), "x11"),
ParameterUncertainty((-2.5, 2.5), "x12")
]
if __name__ == "__main__":
#turn on logging
ema_logging.log_to_stderr(ema_logging.INFO)
#instantiate a model
wd = r'./models/vensim example'
vensimModel = VensimExampleModel(wd, "simpleModel")
#instantiate an ensemble
ensemble = ModelEnsemble()
#set the model on the ensemble
ensemble.model_structure = vensimModel
#run in parallel, if not set, FALSE is assumed
ensemble.parallel = True
#perform experiments
result = ensemble.perform_experiments(1000)
