def test_multiple_models(self): """ Test running running with two different pysd models Returns ------- """ relative_path_to_file = '../models/Sales_Agent_Market_Building_Dynamics.mdl' directory = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) mdl_file = os.path.join(directory, relative_path_to_file) market_model = PysdModel(mdl_file=mdl_file) market_model.uncertainties = [RealParameter('Startup Subsidy',0, 3), RealParameter('Startup Subsidy Length', 0, 10)] market_model.outcomes = [TimeSeriesOutcome('Still Employed')] relative_path_to_file = '../models/Sales_Agent_Motivation_Dynamics.mdl' directory = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) mdl_file = os.path.join(directory, relative_path_to_file) motivation_model = PysdModel(mdl_file=mdl_file) motivation_model.uncertainties = [RealParameter('Startup Subsidy', 0, 3), RealParameter('Startup Subsidy Length', 0, 10)] motivation_model.outcomes =[TimeSeriesOutcome('Still Employed')] ensemble = ModelEnsemble() # instantiate an ensemble ensemble.model_structures = [market_model, motivation_model] # set the model on the ensemble ensemble.perform_experiments(5)
def test_parallel_experiment(self): """ Test running an experiment in parallel Returns ------- """ from ema_workbench.connectors import PySDConnector model = PySDConnector('../models/Teacup.mdl', uncertainties_dict={'Room Temperature': (33, 120)}, outcomes_list=['Teacup Temperature']) ensemble = ModelEnsemble() # instantiate an ensemble ensemble.model_structure = model # set the model on the ensemble ensemble.parallel = True results = ensemble.perform_experiments(cases=20)
def test_add_outcomes(self): from ema_workbench.connectors import PySDConnector model = PySDConnector('../models/Teacup.mdl', uncertainties_dict={'Room Temperature': (33, 120)}, outcomes_list=['Teacup Temperature']) ensemble = ModelEnsemble() # instantiate an ensemble ensemble.model_structure = model # set the model on the ensemble ensemble.parallel = False nr_runs = 10 experiments, outcomes = ensemble.perform_experiments(nr_runs) self.assertEqual(experiments.shape[0], nr_runs) self.assertIn('TIME', outcomes.keys()) self.assertIn('Teacup Temperature', 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())
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_multiple_models(self): """ Test running running with two different pysd models Returns ------- """ from ema_workbench.connectors import PySDConnector market_model = PySDConnector('../models/Sales_Agent_Market_Building_Dynamics.mdl', uncertainties_dict={'Startup Subsidy': (0, 3), 'Startup Subsidy Length': (0, 10)}, outcomes_list=['Still Employed']) motivation_model = PySDConnector('../models/Sales_Agent_Market_Building_Dynamics.mdl', uncertainties_dict={'Startup Subsidy': (0, 3), 'Startup Subsidy Length': (0, 10)}, outcomes_list=['Still Employed']) ensemble = ModelEnsemble() # instantiate an ensemble ensemble.model_structures = [market_model, motivation_model] # set the model on the ensemble results = ensemble.perform_experiments(cases=20)
def test_optimization(): if os.name != 'nt': return ema_logging.log_to_stderr(ema_logging.INFO) model = FluModel(r'../models', "fluCase") ensemble = ModelEnsemble() ensemble.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)
def test_parallel_experiment(self): """ Test running an experiment in parallel Returns ------- """ relative_path_to_file = '../models/Teacup.mdl' directory = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) mdl_file = os.path.join(directory, relative_path_to_file) model = PysdModel(mdl_file=mdl_file) model.uncertainties = [RealParameter('Room Temperature', 33, 120)] model.outcomes = [TimeSeriesOutcome('Teacup Temperature')] ensemble = ModelEnsemble() # instantiate an ensemble ensemble.model_structures = model # set the model on the ensemble ensemble.parallel = True ensemble.perform_experiments(5)
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()
ParameterUncertainty, Outcome) 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.parallel = True ensemble.set_model_structure(model) #set the model on the ensemble results = ensemble.perform_experiments(1000) #run 1000 experiments
#note that this reference to the model should be relative #this relative path will be combined with the workingDirectory model_file = r'\model.vpm' #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)
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)
"effect of perceived adequacy on energy drain lookup", self, 0, 10), LookupUncertainty('hearne2', [(-2, 2), (-1, 2), (0, 1.5), (0.1, 1.6), (0.5, 1.5), (0.1, 2)], "effect of perceived adequacy of hours worked lookup", self, 0, 2.5), LookupUncertainty('hearne2', [(-1, 1), (-1, 1), (0, 0.9), (0.1, 1), (0.5, 1.5), (1, 1.5)], "effect of energy levels on hours worked lookup", self, 0, 1.5), LookupUncertainty('hearne2', [(-1, 1), (-1, 1), (0, 0.9), (0.1, 1), (0.5, 1.5), (1, 1.5)], "effect of high energy on further recovery lookup", self, 0, 1.25), LookupUncertainty('hearne2', [(-2, 2), (-1, 1), (0, 100), (20, 120), (0.5, 1.5), (0.5, 2)], "effect of hours worked on energy recovery lookup", self, 0, 1.5), LookupUncertainty('approximation', [(-0.5, 0.35), (3, 5), (1, 10), (0.2, 0.4), (0, 120)], "effect of hours worked on energy drain lookup", self, 0, 3), LookupUncertainty('hearne1', [(0, 1), (0, 0.15), (1, 1.5), (0.75, 1.25)], "effect of low energy on further depletion lookup", self, 0, 1)] self._delete_lookup_uncertainties() if __name__ == "__main__": ema_logging.log_to_stderr(ema_logging.INFO) model = Burnout(r'./models/burnout', "burnout") ensemble = ModelEnsemble() ensemble.model_structures = model #run policy with old cases results = ensemble.perform_experiments(100) lines(results, 'Energy Level', density=BOXPLOT) plt.show()
RealParameter("stdev", 0.001, 0.005), RealParameter("delta", 0.93, 0.99)] #specify outcomes model.outcomes = [ScalarOutcome("max_P",), ScalarOutcome("utility"), ScalarOutcome("inertia"), ScalarOutcome("reliability")] # override some of the defaults of the model model.constants = [Constant('alpha', 0.41), Constant('nsamples', 150),] # set levers, one for each time step model.levers = [RealParameter(str(i), 0, 0.1) for i in range(100)] ensemble = ModelEnsemble() #instantiate an ensemble ensemble.model_structures = model #set the model on the ensemble ensemble.parallel = True ensemble.processes = 1 # generate some random policies by sampling over levers policies, levers, n = samplers.sample_levers(ensemble.model_structures, 4, sampler=samplers.MonteCarloSampler()) # policies is a generator, so let's exhaust the generator policies = [policy for policy in policies] # policy name defaults to a repr(dict), let's rename for i, policy in enumerate(policies): policy.name = str(i)
"normal contact rate region 2")] def model_init(self, policy, kwargs): '''initializes the model''' try: self.model_file = policy['file'] except KeyError: ema_logging.warning("key 'file' not found in policy") super(FluModel, self).model_init(policy, kwargs) if __name__ == "__main__": ema_logging.log_to_stderr(ema_logging.INFO) model = FluModel(r'./models/flu', "flucase") ensemble = ModelEnsemble() ensemble.model_structure = model #add policies policies = [{'name': 'no policy', 'file': r'\FLUvensimV1basecase.vpm'}, {'name': 'static policy', 'file': r'\FLUvensimV1static.vpm'}, {'name': 'adaptive policy', 'file': r'\FLUvensimV1dynamic.vpm'} ] ensemble.policies = policies #turn on parallel processing ensemble.parallel = True
Outcome('grass', time=True) # TODO patches not working in reporting ] if __name__ == "__main__": import multiprocessing ema_logging.LOG_FORMAT = multiprocessing.util.DEFAULT_LOGGING_FORMAT #turn on logging ema_logging.log_to_stderr(ema_logging.DEBUG) ema_logging.info('in main') #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 ensemble.processes = 2 #perform experiments results = ensemble.perform_experiments(10, reporting_interval=1) plotting.lines(results, density=plotting_util.KDE) plt.show()
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_FORMAT = '[%(name)s/%(levelname)s/%(processName)s] %(message)s' 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, reporting_interval=1) #run 1000 experiments
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)
a_mean = np.mean(a) b_mean = np.mean(b) if a_mean < 0.5 or b_mean < 0.5: return (np.inf,) * 2 else: return a_mean, b_mean if __name__ == "__main__": ema_logging.log_to_stderr(ema_logging.INFO) model = DummyModel(r"", "dummy") np.random.seed(123456789) ensemble = ModelEnsemble() ensemble.set_model_structure(model) policy_levers = {'Trigger a': {'type':'list', 'values':[0, 0.25, 0.5, 0.75, 1]}, 'Trigger b': {'type':'list', 'values':[0, 0.25, 0.5, 0.75, 1]}, 'Trigger c': {'type':'list', 'values':[0, 0.25, 0.5, 0.75, 1]}} cases = ensemble._generate_samples(10, UNION)[0] ensemble.add_policy({"name":None}) experiments = [entry for entry in ensemble._generate_experiments(cases)] for entry in experiments: entry.pop("model") entry.pop("policy") cases = 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)
speed = kwargs.pop("lookup price substitute speed") begin = kwargs.pop("lookup price substitute begin") end = kwargs.pop("lookup price substitute end") lookup = [self.priceSubstite(x, speed, begin, end) for x in range(0,100, 10)] kwargs['relative price substitute lookup'] = lookup scale = kwargs.pop("lookup returns to scale speed") speed = kwargs.pop("lookup returns to scale scale") lookup = [self.returnsToScale(x, speed, scale) for x in range(0, 101, 10)] kwargs['returns to scale lookup'] = lookup scale = kwargs.pop("lookup approximated learning speed") speed = kwargs.pop("lookup approximated learning scale") start = kwargs.pop("lookup approximated learning start") lookup = [self.approxLearning(x, speed, scale, start) for x in range(0, 101, 10)] kwargs['approximated learning effect lookup'] = lookup super(ScarcityModel, self).run_model(kwargs) if __name__ == "__main__": ema_logging.log_to_stderr(ema_logging.DEBUG) model = ScarcityModel(r'./models/scarcity', "scarcity") ensemble = ModelEnsemble() ensemble.model_structure = model ensemble.parallel = True results = ensemble.perform_experiments(2)