def run_model(_model: str, _profile: str, camp: str, load_from_cache: bool,
save_to_cache: bool, is_save_plots: bool, is_show_plots: bool,
is_save_report: bool, overrides) -> ModelResult:
logging.info('Running %s model with %s profile', _model, _profile)
_mdl: Model = get_models()[_model](facade.ps)
params = create_params(facade.ps, _model, _profile, camp, overrides)
res_id = _mdl.result_id(params)
if load_from_cache and facade.rs.exists(_mdl.id(), res_id):
logging.info("Loading from model result cache")
mr: ModelResult = facade.rs.load(_mdl.id(), res_id)
else:
logging.info("Running model for camp %s", camp)
mr: ModelResult = _mdl.run(params)
if save_to_cache:
logging.info("Saving model result to cache")
facade.rs.store(_mdl.id(), res_id, mr)
if is_save_plots or is_show_plots:
# if _mdl.id() == 'agent-based-model':
save_plots(mr, res_id, is_save_plots, is_show_plots)
# save_plots_abm(mr, res_id, is_save_plots, is_show_plots)
# else:
# save_plots(mr, res_id, is_save_plots, is_show_plots)
if is_save_report:
save_report(mr, res_id)
return mr
def find_profile(m, c, rid):
_mdl = get_models()[m](facade.ps)
for p in facade.ps.get_profiles(m):
params = create_params(facade.ps, m, p, c)
res_id = _mdl.result_id(params)
if res_id == rid:
return p
return None
def _sync_run_model(facade, _model: str, _profile: str, camp: str) -> ModelResult:
logger.info('Running %s model with %s profile', _model, _profile)
_mdl: Model = get_models()[_model](facade.ps)
params = create_params(facade.ps, _model, _profile, camp)
res_id = _mdl.result_id(params)
logger.info("Running model for camp %s", camp)
mr = _mdl.run(params)
logger.info("Saving model result to cache")
facade.rs.store(_mdl.id(), res_id, mr)
return mr
def _sync_run_model(self, _model: str, _profile: str,
camp: str) -> ModelResult:
logging.info('Running %s model with %s profile', _model, _profile)
_mdl: Model = get_models()[_model](self.facade.ps)
params = create_params(self.facade.ps, _model, _profile, camp)
res_id = _mdl.result_id(params)
if self.facade.rs.exists(_mdl.id(), res_id):
logging.info("Loading from model result cache")
return self.facade.rs.load(_mdl.id(), res_id)
else:
logging.info("Running model for camp %s", camp)
mr = _mdl.run(params)
logging.info("Saving model result to cache")
self.facade.rs.store(_mdl.id(), res_id, mr)
return mr
def run_model(
self, _model: str, _profile: str, camp: str
) -> ModelResult: #TODO: prevent double exec while in progress
logging.info('Running %s model with %s profile', _model, _profile)
_mdl: Model = get_models()[_model](self.facade.ps)
res_id = _mdl.result_id(camp, _profile)
if self.facade.rs.exists(_mdl.id(), res_id):
logging.info("Loading from model result cache")
return self.facade.rs.load(_mdl.id(), res_id)
else:
logging.info("Running model for camp %s",
camp) #TODO: add async and progress
mr = _mdl.run(camp, _profile)
logging.info("Saving model result to cache")
self.facade.rs.store(_mdl.id(), res_id, mr)
return mr
def cache_info():
def find_profile(m, c, rid):
_mdl = get_models()[m](facade.ps)
for p in facade.ps.get_profiles(m):
params = create_params(facade.ps, m, p, c)
res_id = _mdl.result_id(params)
if res_id == rid:
return p
return None
for m in get_models():
cached_data = facade.rs.list(m)
print(f"---- {m} ----")
for cd in cached_data:
rid = facade.rs.result_id_from_file_name(cd, m)
mr: ModelResult = facade.rs.load(m, rid)
p = mr.get('params')
profile_info = find_profile(m, p.camp, rid)
if profile_info is None:
profile_info = str(p.control_dict)
print(f'{rid}\t{p.camp}\t{profile_info}')
def get_result(self, _model: str, _profile: str, camp: str) -> ModelResult:
_mdl: Model = get_models()[_model](self.facade.ps)
params = create_params(self.facade.ps, _model, _profile, camp)
res_id = _mdl.result_id(params)
return self.facade.rs.load(_mdl.id(), res_id)
def results_exist(self, _model: str, _profile: str, camp: str) -> bool:
_mdl: Model = get_models()[_model](self.facade.ps)
params = create_params(self.facade.ps, _model, _profile, camp)
res_id = _mdl.result_id(params)
return self.facade.rs.exists(_mdl.id(), res_id)
def get_result(self, _model: str, _profile: str, camp: str) -> ModelResult:
_mdl: Model = get_models()[_model](self.facade.ps)
res_id = _mdl.result_id(camp, _profile)
return self.facade.rs.load(_mdl.id(), res_id)
def results_exist(self, _model: str, _profile: str, camp: str) -> bool:
_mdl: Model = get_models()[_model](self.facade.ps)
res_id = _mdl.result_id(camp, _profile)
return self.facade.rs.exists(_mdl.id(), res_id)
pu.fig_path(f"Age_structure_(bar_chart)_{res_id}.png"))
fig_uncertainty.write_image(pu.fig_path(f"Uncertainty_{res_id}.png"))
def save_report(mr, res_id):
logging.info("Saving report")
df = mr.get('report')
df.to_csv(pu.reports_path(f"all_R0_{res_id}.csv"))
if __name__ == '__main__':
logging.basicConfig(level=logging.DEBUG)
parser = argparse.ArgumentParser(description='AI4Good model runner')
parser.add_argument('--model',
type=str,
choices=get_models().keys(),
help='Model to run',
default=CompartmentalModel.ID)
profile_group = parser.add_mutually_exclusive_group()
profile_group.add_argument(
'--profile',
type=str,
help='Model profile to run, by default first one will be run')
profile_group.add_argument('--run_all_profiles',
action='store_true',
help='Run all profiles in the model',
default=False)
camp_group = parser.add_mutually_exclusive_group()
camp_group.add_argument('--camp',
type=str,
def setUp(self) -> None:
self.facade = Facade.simple()
self.mdl = get_models()['compartmental-model'](self.facade.ps)
