def parameters_deserializer(p_json: str): values = loads(p_json) result = Parameters( current_hospitalized=values["current_hospitalized"], hospitalized=Disposition(*values["hospitalized"]), icu=Disposition(*values["icu"]), relative_contact_rate=values["relative_contact_rate"], ventilated=Disposition(*values["ventilated"]), current_date=parse_date(values["current_date"]), date_first_hospitalized=values["date_first_hospitalized"], doubling_time=values["doubling_time"], infectious_days=values["infectious_days"], market_share=values["market_share"], max_y_axis=values["max_y_axis"], n_days=values["n_days"], population=values["population"], recovered=values["recovered"], region=values["region"], ) for key, value in values.items(): if result.__dict__[key] != value and key not in ("dispositions", "hospitalized", "icu", "ventilated", "current_date"): result.__dict__[key] = value return result
def create_params_from_file(file): """ Create CHIME Parameters object from input config file :param file: :return: """ # Update sys.arg so we can call cli.parse_args() sys.argv = [sys.argv[0], '--file', file] a = cli.parse_args() p = Parameters( current_hospitalized=a.current_hospitalized, infectious_days=a.infectious_days, market_share=a.market_share, n_days=a.n_days, relative_contact_rate=a.relative_contact_rate, population=a.population, hospitalized=Disposition(a.hospitalized_rate, a.hospitalized_days), icu=Disposition(a.icu_rate, a.icu_days), ventilated=Disposition(a.ventilated_rate, a.ventilated_days), ) if a.date_first_hospitalized is None: p.doubling_time = a.doubling_time else: p.date_first_hospitalized = a.date_first_hospitalized return p
def get_parameters_for_region(region_population, region_cases, num_days=60, param_override=None): if param_override is None: param_override = {} p = dict( ChainMap( { # Hospital Market Share (0.00001 - 1.0) "market_share": 1.0, # Currently Known Regional Infections (>=0) "known_infected": region_cases, # Number of days to project >= 0 "n_days": num_days, # Seems like a viz thing "as_date": False, }, DEFAULT_PARAMS, param_override)) p['current_hospitalized'] = None # Unused for regional calculation p['hospitalized'] = RateLos(p['hospitalized_rate'], p['hospitalized_los']) del p['hospitalized_rate'] del p['hospitalized_los'] p['icu'] = RateLos(p['icu_rate'], p['icu_los']) del p['icu_rate'] del p['icu_los'] p['ventilated'] = RateLos(p['ventilated_rate'], p['ventilated_los']) del p['ventilated_rate'] del p['ventilated_los'] detection_probability = p['detection_probability'] del p['detection_probability'] p['population'] = region_population chime_params = Parameters(**p) chime_params.detection_probability = detection_probability return chime_params
def update_parameters(i, *input_values) -> List[dict]: """Reads html form outputs and converts them to a parameter instance Returns Parameters """ inputs_dict = SidebarCallbacks.get_formated_values(i, input_values) dt = inputs_dict["doubling_time"] if inputs_dict["doubling_time"] else None dfh = inputs_dict["date_first_hospitalized"] if not dt else None pars = Parameters( current_hospitalized=inputs_dict["current_hospitalized"], date_first_hospitalized=dfh, doubling_time=dt, hospitalized=Disposition.create( days=inputs_dict["hospitalized_los"], rate=inputs_dict["hospitalized_rate"] / 100, ), icu=Disposition( days=inputs_dict["icu_los"], rate=inputs_dict["icu_rate"] / 100, ), infectious_days=inputs_dict["infectious_days"], market_share=inputs_dict["market_share"] / 100, n_days=inputs_dict["n_days"], population=inputs_dict["population"], recovered=0, #FIXME input or pass through from defaults is required! relative_contact_rate=inputs_dict["relative_contact_rate"] / 100, ventilated=Disposition.create( days=inputs_dict["ventilated_los"], rate=inputs_dict["ventilated_rate"] / 100, ), max_y_axis=inputs_dict.get("max_y_axis_value", None), ) return [{"inputs_dict": inputs_dict, "parameters": parameters_serializer(pars)}]
def update_parameters(*input_values, **kwargs) -> List[str]: """Reads html form outputs and converts them to a parameter instance Returns Parameters """ inputs_dict = Sidebar.get_formated_values(input_values) dt = inputs_dict["doubling_time"] if inputs_dict["doubling_time"] else None dfh = inputs_dict["date_first_hospitalized"] if not dt else None pars = Parameters( population=inputs_dict["population"], current_hospitalized=inputs_dict["current_hospitalized"], date_first_hospitalized=dfh, doubling_time=dt, hospitalized=Disposition( inputs_dict["hospitalized_rate"] / 100, inputs_dict["hospitalized_los"] ), icu=Disposition(inputs_dict["icu_rate"] / 100, inputs_dict["icu_los"]), infectious_days=inputs_dict["infectious_days"], market_share=inputs_dict["market_share"] / 100, n_days=inputs_dict["n_days"], relative_contact_rate=inputs_dict["relative_contact_rate"] / 100, ventilated=Disposition( inputs_dict["ventilated_rate"] / 100, inputs_dict["ventilated_los"] ), max_y_axis=inputs_dict.get("max_y_axis_value", None), ) return [parameters_serializer(pars)]
def post_args(): args = request.json args['hospitalized'] = RateLos(args['hospitalized_rate'], args['hospitalized_los']) args['icu'] = RateLos(args['icu_rate'], args['icu_los']) args['ventilated'] = RateLos(args['ventilated_rate'], args['ventilated_los']) del args['hospitalized_rate'] del args['hospitalized_los'] del args['icu_rate'] del args['icu_los'] del args['ventilated_rate'] del args['ventilated_los'] p = Parameters(**args) m = SimSirModel(p) files = [] prefix = datetime.now().strftime("%Y.%m.%d.%H.%M.") for df, name in ( (m.raw_df, "raw"), (m.admits_df, "admits"), (m.census_df, "census"), ): filename = path.join(gettempdir(), prefix + name + ".csv") df.to_csv(filename) files.append(filename) zipfilename = path.join(gettempdir(), prefix + 'result.zip') with ZipFile(zipfilename, 'w') as zip: for file in files: zip.write(file, path.basename(file)) return send_file(zipfilename)
def main(): """Main.""" my_args = parse_args() my_args_dict = vars(my_args) # Update sys.arg so we can call cli.parse_args() sys.argv = [sys.argv[0], '--file', my_args_dict['file']] a = cli.parse_args() p = Parameters( current_hospitalized=a.current_hospitalized, date_first_hospitalized=a.date_first_hospitalized, doubling_time=a.doubling_time, infectious_days=a.infectious_days, market_share=a.market_share, n_days=a.n_days, relative_contact_rate=a.relative_contact_rate, population=a.population, hospitalized=Disposition(a.hospitalized_rate, a.hospitalized_days), icu=Disposition(a.icu_rate, a.icu_days), ventilated=Disposition(a.ventilated_rate, a.ventilated_days), ) m = Model(p) for df, name in ( (m.sim_sir_w_date_df, "sim_sir_w_date"), (m.admits_df, "projected_admits"), (m.census_df, "projected_census"), ): df.to_csv(f"{p.current_date}_{name}.csv")
def main(): """Main.""" a = parse_args() p = Parameters( current_hospitalized=a.current_hospitalized, doubling_time=a.doubling_time, known_infected=a.known_infected, market_share=a.market_share, relative_contact_rate=a.relative_contact_rate, susceptible=a.susceptible, n_days=a.n_days, hospitalized=RateLos(a.hospitalized_rate, a.hospitalized_los), icu=RateLos(a.icu_rate, a.icu_los), ventilated=RateLos(a.ventilated_rate, a.ventilated_los), ) raw_df = DataFrame({ "Susceptible": p.susceptible_v, "Infected": p.infected_v, "Recovered": p.recovered_v, }) admits_df = build_admissions_df(p) census_df = build_census_df(admits_df, p) prefix = a.prefix for df, name in ( (raw_df, "raw"), (admits_df, "admits"), (census_df, "census"), ): df.to_csv(prefix + name + ".csv")
def create_app(context: str = 'prod') -> DashAppInstance: """ create_app initializes the app instance Args: context (str, optional): One of either 'prod', 'dev', 'testing. Defaults to 'prod' where dash.Dash.run_server(debug=False). Change to 'dev' or 'test' to set debug to true. Returns: Env: Config variables based on context argument received DashAppInstance: Dash instance with appropriate configuration settings """ Env = from_object(context) LANGUAGE = Env.LANG body = Root( LANGUAGE, Parameters.create(os.environ, []), ) App = Dash( __name__, external_stylesheets=body.external_stylesheets, external_scripts=body.external_scripts, ) App.title = Env.CHIME_TITLE App.layout = body.html wrap_callbacks(App) return Env, App
def main(): """Main.""" a = parse_args() p = Parameters( current_hospitalized=a.current_hospitalized, doubling_time=a.doubling_time, known_infected=a.known_infected, market_share=a.market_share, n_days=a.n_days, relative_contact_rate=a.relative_contact_rate, susceptible=a.susceptible, hospitalized=RateLos(a.hospitalized_rate, a.hospitalized_los), icu=RateLos(a.icu_rate, a.icu_los), ventilated=RateLos(a.ventilated_rate, a.ventilated_los), ) m = SimSirModel(p) prefix = a.prefix for df, name in ( (m.raw_df, "raw"), (m.admits_df, "admits"), (m.census_df, "census"), ): df.to_csv(prefix + name + ".csv")
def sim_chimes(scenarios: str, p: Parameters = None): """ Run many chime simulations. If `params` is not None, then it is used to initialize all parameters. Any parameter values set to something other than None in the following optional args will update that parameter value. If `params` is None, then all additional args must be other than None. These settings are just for the base parameter values. We can run stuff over ranges as we see it. :param scenarios: :param params: :return: """ base_input_params_dict = vars(p) # Create a range of social distances soc_dists = np.arange(0.05, 0.60, 0.05) # array([0.05, 0.1 , 0.15, 0.2 , 0.25, 0.3 , 0.35, 0.4 , 0.45, 0.5 , 0.55, 0.6 ]) num_scenarios = len(soc_dists) # We can store outputs any way we want. For this demo, just going to # use a master list. # This will be a list of dicts of the # result dataframes (+ 1 dict containing the scenario inputs) results_list = [] for sd_pct in soc_dists: sim_scenario = '{}{:.0f}'.format(scenarios, 100 * sd_pct) # Update the parameters for this scenario p.relative_contact_rate = sd_pct input_params_dict = vars(p) # Run the model m = Model.SimSirModel(p) # Gather results results = gather_sim_results(m, sim_scenario, input_params_dict) # Append results to results list results_list.append(results.copy()) return results_list
def parse_form_parameters(**kwargs) -> Tuple[Parameters, Dict[str, Any]]: """Reads html form outputs and converts them to a parameter instance Returns Parameters and as_date argument """ pars = Parameters( current_hospitalized=kwargs["current_hospitalized"], doubling_time=kwargs["doubling_time"], known_infected=kwargs["known_infected"], market_share=kwargs["market_share"] / 100, relative_contact_rate=kwargs["relative_contact_rate"] / 100, susceptible=kwargs["susceptible"], hospitalized=RateLos(kwargs["hospitalized_rate"] / 100, kwargs["hospitalized_los"]), icu=RateLos(kwargs["icu_rate"] / 100, kwargs["icu_los"]), ventilated=RateLos(kwargs["ventilated_rate"] / 100, kwargs["ventilated_los"]), max_y_axis=kwargs["max_y_axis_value"], n_days=kwargs["n_days"], ) return pars
def parameters_deserializer(p_json: str): values = loads(p_json) dates = { key: parse_date(values[key]).date() if values[key] else None for key in ( "current_date", "date_first_hospitalized", "mitigation_date", ) } return Parameters( current_date=dates["current_date"], current_hospitalized=values["current_hospitalized"], hospitalized=Disposition.create( days=values["hospitalized"][0], rate=values["hospitalized"][1], ), icu=Disposition.create( days=values["icu"][0], rate=values["icu"][1], ), infectious_days=values["infectious_days"], date_first_hospitalized=dates["date_first_hospitalized"], doubling_time=values["doubling_time"], market_share=values["market_share"], max_y_axis=values["max_y_axis"], mitigation_date=dates["mitigation_date"], n_days=values["n_days"], population=values["population"], recovered=values["recovered"], region=values["region"], relative_contact_rate=values["relative_contact_rate"], ventilated=Disposition.create( days=values["ventilated"][0], rate=values["ventilated"][1], ), )
def sim_chimes( scenarios: str, params: Parameters = None, current_hospitalized: int = None, doubling_time: float = None, known_infected: int = None, relative_contact_rate: float = None, susceptible: int = None, hospitalized: RateLos = None, icu: RateLos = None, ventilated: RateLos = None, market_share: float = None, n_days: int = None, recovery_days: float = None, ): """ Run many chime simulations. If `params` is not None, then it is used to initialize all parameters. Any parameter values set to something other than None in the following optional args will update that parameter value. If `params` is None, then all additional args must be other than None. These settings are just for the base parameter values. We can run stuff over ranges as we see it. :param scenarios: :param params: :param current_hospitalized: :param doubling_time: :param known_infected: :param relative_contact_rate: :param susceptible: :param hospitalized: :param icu: :param ventilated: :param market_share: :param n_days: :param recovery_days: :return: """ if params is not None: params_dict = vars(params) else: params_dict = { "current_hospitalized": None, "doubling_time": None, "known_infected": None, "relative_contact_rate": None, "susceptible": None, "hospitalized": None, "icu": None, "ventilated": None, "market_share": None, "n_days": None, "recovery_days": None, } # Check for parameter updates passed vals_passed = { key: value for (key, value) in vars().items() if key not in ['scenario', 'params'] } for key, value in vals_passed.items(): if value is not None: params_dict[key] = value # Create Parameters object p = Parameters( current_hospitalized=params_dict['current_hospitalized'], doubling_time=params_dict['doubling_time'], known_infected=params_dict['known_infected'], market_share=params_dict['market_share'], n_days=params_dict['n_days'], relative_contact_rate=params_dict['relative_contact_rate'], susceptible=params_dict['susceptible'], hospitalized=params_dict['hospitalized'], icu=params_dict['icu'], ventilated=params_dict['ventilated'], ) base_input_params_dict = vars(p) # Create a range of social distances soc_dists = np.arange(0.05, 0.60, 0.05) # array([0.05, 0.1 , 0.15, 0.2 , 0.25, 0.3 , 0.35, 0.4 , 0.45, 0.5 , 0.55, # 0.6 , 0.65, 0.7 , 0.75, 0.8 , 0.85]) num_scenarios = len(soc_dists) # We can store outputs any way we want. For this demo, just going to # use a master list. # This will be a list of dicts of the # result dataframes (+ 1 dict containing the scenario inputs) results_list = [] for sdpct in soc_dists: sim_scenario = '{}{:.0f}'.format(scenarios, 100 * sdpct) # Update the parameters for this scenario p.relative_contact_rate = sdpct input_params_dict = vars(p) # Run the model m = SimSirModel(p) # Gather results results = gather_sim_results(m, sim_scenario, input_params_dict) # Append results to results list results_list.append(results.copy()) return results_list
def sim_chime( sim_scenario: str, params: Parameters = None, current_hospitalized: int = None, doubling_time: float = None, known_infected: int = None, relative_contact_rate: float = None, susceptible: int = None, hospitalized: RateLos = None, icu: RateLos = None, ventilated: RateLos = None, market_share: float = None, n_days: int = None, recovery_days: float = None, ): """ Run one chime simulation. If `params` is not None, then it is used to initialize all parameters. Any parameter values set to something other than None in the following optional args will update that parameter value. If `params` is None, then all additional args must be other than None. :param sim_scenario: :param params: :param current_hospitalized: :param doubling_time: :param known_infected: :param relative_contact_rate: :param susceptible: :param hospitalized: :param icu: :param ventilated: :param market_share: :param n_days: :param recovery_days: :return: """ if params is not None: params_dict = vars(params) else: params_dict = { "current_hospitalized": None, "doubling_time": None, "known_infected": None, "relative_contact_rate": None, "susceptible": None, "hospitalized": None, "icu": None, "ventilated": None, "market_share": None, "n_days": None, "recovery_days": None, } # Check for parameter updates passed vals_passed = { key: value for (key, value) in vars().items() if key not in ['scenario', 'params'] } for key, value in vals_passed.items(): if value is not None: params_dict[key] = value # Create Parameters object p = Parameters( current_hospitalized=params_dict['current_hospitalized'], doubling_time=params_dict['doubling_time'], known_infected=params_dict['known_infected'], market_share=params_dict['market_share'], n_days=params_dict['n_days'], relative_contact_rate=params_dict['relative_contact_rate'], susceptible=params_dict['susceptible'], hospitalized=params_dict['hospitalized'], icu=params_dict['icu'], ventilated=params_dict['ventilated'], ) input_params_dict = vars(p) # Run the model m = SimSirModel(p) # Gather results results = gather_sim_results(m, sim_scenario, input_params_dict) return results
return results_list if __name__ == "__main__": a = parse_args() scenario = a.scenario output_path = a.output_path if a.use_defaults: p = Parameters( current_hospitalized=DEFAULTS.current_hospitalized, doubling_time=DEFAULTS.doubling_time, known_infected=DEFAULTS.known_infected, market_share=DEFAULTS.market_share, n_days=DEFAULTS.n_days, relative_contact_rate=DEFAULTS.relative_contact_rate, susceptible=DEFAULTS.region.susceptible, hospitalized=RateLos(DEFAULTS.hospitalized.rate, DEFAULTS.hospitalized.length_of_stay), icu=RateLos(DEFAULTS.icu.rate, DEFAULTS.icu.length_of_stay), ventilated=RateLos(DEFAULTS.ventilated.rate, DEFAULTS.ventilated.length_of_stay), ) else: p = Parameters( current_hospitalized=a.current_hospitalized, doubling_time=a.doubling_time, known_infected=a.known_infected, market_share=a.market_share, n_days=a.n_days, relative_contact_rate=a.relative_contact_rate, susceptible=a.susceptible,
from penn_chime.models import SimSirModel from penn_chime.charts import ( build_admits_chart, build_census_chart, build_descriptions, build_sim_sir_w_date_chart, build_table, ) # This is somewhat dangerous: # Hide the main menu with "Rerun", "run on Save", "clear cache", and "record a screencast" # This should not be hidden in prod, but removed # In dev, this should be shown st.markdown(hide_menu_style, unsafe_allow_html=True) d = Parameters.create(os.environ, []) p = display_sidebar(st, d) m = SimSirModel(p) display_header(st, m, p) st.subheader("New Admissions") st.markdown( "Projected number of **daily** COVID-19 admissions. \n\n _NOTE: Now including estimates of prior admissions for comparison._" ) admits_chart = build_admits_chart(alt=alt, admits_floor_df=m.admits_floor_df, max_y_axis=p.max_y_axis) st.altair_chart(admits_chart, use_container_width=True) st.markdown( build_descriptions(chart=admits_chart,
def get_model_from_params(parameters, region_results): p = get_model_params(parameters, region_results) print(p) params_obj = Parameters(**p) m = penn_chime.models.SimSirModel(params_obj) return m, p
# Update sys.arg so we can call cli.parse_args() sys.argv = [sys.argv[0], '--file', my_args_dict['file']] scenario = my_args.scenario output_path = my_args.output_path # Read chime params from configuration file a = cli.parse_args() p = Parameters( current_hospitalized=a.current_hospitalized, date_first_hospitalized=a.date_first_hospitalized, doubling_time=a.doubling_time, infectious_days=a.infectious_days, market_share=a.market_share, n_days=a.n_days, relative_contact_rate=a.relative_contact_rate, population=a.population, hospitalized=Disposition(a.hospitalized_rate, a.hospitalized_days), icu=Disposition(a.icu_rate, a.icu_days), ventilated=Disposition(a.ventilated_rate, a.ventilated_days), ) if my_args.scenarios is None: # Just running one scenario results = sim_chime(scenario, p) if not a.quiet: print("Scenario: {}\n".format(results['scenario_str'])) print("\nInput parameters") print("{}".format(50 * '-'))
def test_cypress_defaults(): """Ensure the cypress defaults have been updated.""" # TODO how to make this work when the module is installed? _ = Parameters.create({"PARAMETERS": "./defaults/cypress.cfg"}, [])