def run_calibration_chain(max_seconds: int, run_id: int, num_chains: int): targets = load_targets("sir_example", Region.VICTORIA) params = load_params("sir_example", Region.VICTORIA) prevalence_infectious = targets["prevalence_infectious"] target_outputs = [ { "output_key": prevalence_infectious["output_key"], "years": prevalence_infectious["times"], "values": prevalence_infectious["values"], "loglikelihood_distri": "normal", "time_weights": list(range(1, len(prevalence_infectious["times"]) + 1)), }, ] calib = Calibration( "sir_example", build_model, params, PRIORS, target_outputs, run_id, num_chains, region_name=Region.AUSTRALIA, ) calib.run_fitting_algorithm( run_mode="autumn_mcmc", n_chains=1, available_time=max_seconds, )
def get_target_outputs(start_date, end_date): targets = load_targets("covid_19", Region.VICTORIA) # Total Victorian notifications for each time point notification_times, notification_values = get_truncated_output( targets["notifications"], start_date, end_date) notification_values = [round(value) for value in notification_values] target_outputs = [{ "output_key": "notifications", "years": notification_times, "values": notification_values, "loglikelihood_distri": "poisson", }] death_times, death_values = get_truncated_output( targets["infection_deaths"], start_date, end_date) target_outputs += [{ "output_key": "infection_deaths", "years": death_times, "values": apply_moving_average(death_values, 7), "loglikelihood_distri": "poisson", }] hospitalisation_times, hospitalisation_values = get_truncated_output( targets["hospital_admissions"], start_date, end_date) target_outputs += [{ "output_key": "hospital_admissions", "years": hospitalisation_times, "values": hospitalisation_values, "loglikelihood_distri": "poisson", }] icu_admission_times, icu_admission_values = get_truncated_output( targets["icu_admissions"], start_date, end_date) target_outputs += [{ "output_key": "icu_admissions", "years": icu_admission_times, "values": icu_admission_values, "loglikelihood_distri": "poisson", }] # Smoothed notifications for all clusters for cluster in CLUSTERS: output_key = f"notifications_for_cluster_{cluster}" cluster_notification_targets = apply_moving_average( targets[output_key]["values"], period=4) dispersion_value = max( cluster_notification_targets) * DISPERSION_TARGET_RATIO target_outputs += [{ "output_key": output_key, "years": targets[output_key]["times"], "values": cluster_notification_targets, "loglikelihood_distri": "normal", "sd": dispersion_value, }] return target_outputs
def run_dashboard(): app_name, app_dirpath = selectors.app_name(run_type="calibrate") if not app_name: st.write("No calibrations have been run yet") return # Prelims n_countries = st.sidebar.slider("Number of countries", 2, 6, 3) ( region_names, region_dirpaths, calib_names, calib_dirpaths, mcmc_tables, mcmc_params, targets, ) = ({}, {}, {}, {}, {}, {}, {}) for i_region in range(n_countries): # Get regions for comparison region_names[i_region], region_dirpaths[ i_region] = selectors.output_region_name( app_dirpath, f"Select region #{str(i_region)}") if not region_names[i_region]: st.write("No region folder found") return # Specific calibration run name and path calib_names[i_region], calib_dirpaths[ i_region] = selectors.calibration_run( region_dirpaths[i_region], f"Select region #{str(i_region)}") if not calib_names[i_region]: st.write("No model run folder found") return # Load MCMC tables mcmc_tables[i_region] = db.load.load_mcmc_tables( calib_dirpaths[i_region]) mcmc_params[i_region] = db.load.load_mcmc_params_tables( calib_dirpaths[i_region]) targets[i_region] = load_targets(app_name, region_names[i_region]) plot_type = "Multi-country uncertainty" plot_func = PLOT_FUNCS[plot_type] plotter = StreamlitPlotter(targets[0]) plot_func(plotter, calib_dirpaths, mcmc_tables, mcmc_params, targets, app_name, region_names)
def run_dashboard(): app_name, app_dirpath = "covid_19", os.path.join( os.getcwd(), "data\outputs\calibrate\covid_19") if not app_name: st.write("No calibrations have been run yet") return region_name = "victoria" region_dirpath = os.path.join(app_dirpath, region_name) if not region_name: st.write("No region folder found") return calib_name, calib_dirpath = selectors.calibration_run( region_dirpath, region_name) if not calib_name: st.write("No model run folder found") return # Load MCMC tables mcmc_tables = db.load.load_mcmc_tables(calib_dirpath) mcmc_params = db.load.load_mcmc_params_tables(calib_dirpath) targets = load_targets(app_name, region_name) plotter = StreamlitPlotter(targets) plot_type = st.sidebar.selectbox("Select plot type", list(PLOT_FUNCS.keys())) plot_func = PLOT_FUNCS[plot_type] plot_func( plotter, calib_dirpath, mcmc_tables, mcmc_params, targets, app_name, region_name, ) path_name = os.path.join(calib_dirpath, "saved_plots") if not os.path.exists(path_name): os.makedirs(path_name) with st.spinner("Saving files..."): file_plotter = FilePlotter(path_name, targets) plot_func(file_plotter, calib_dirpath, mcmc_tables, mcmc_params, targets, app_name, region_name)
def run_dashboard(): app_name, app_dirpath = selectors.app_name(run_type="calibrate") if not app_name: st.write("No calibrations have been run yet") return region_name, region_dirpath = selectors.output_region_name( app_dirpath, app_name) if not region_name: st.write("No region folder found") return calib_name, calib_dirpath = selectors.calibration_run( region_dirpath, region_name) if not calib_name: st.write("No model run folder found") return # Load MCMC tables mcmc_tables = db.load.load_mcmc_tables(calib_dirpath) mcmc_params = db.load.load_mcmc_params_tables(calib_dirpath) targets = load_targets(app_name, region_name) plotter = StreamlitPlotter(targets) plot_type = st.sidebar.selectbox("Select plot type", list(PLOT_FUNCS.keys())) plot_func = PLOT_FUNCS[plot_type] plot_func( plotter, calib_dirpath, mcmc_tables, mcmc_params, targets, app_name, region_name, )
import logging from apps.tuberculosis.calibration_utils import get_natural_history_priors_from_cid from apps.tuberculosis.model import build_model from autumn.calibration import Calibration from autumn.calibration.utils import add_dispersion_param_prior_for_gaussian from autumn.region import Region from autumn.utils.params import load_params, load_targets targets = load_targets("tuberculosis", Region.MARSHALL_ISLANDS) def run_calibration_chain(max_seconds: int, run_id: int, num_chains: int): params = load_params("tuberculosis", Region.MARSHALL_ISLANDS) calib = Calibration( "tuberculosis", build_model, params, PRIORS, TARGET_OUTPUTS, run_id, num_chains, region_name=Region.MARSHALL_ISLANDS, initialisation_type=params["default"]["metropolis_initialisation"], metropolis_init_rel_step_size=0.10, ) calib.run_fitting_algorithm( run_mode="autumn_mcmc", n_chains=1, available_time=max_seconds, haario_scaling_factor=params["default"]["haario_scaling_factor"],
from apps.covid_19 import calibration as base from apps.covid_19.calibration import ( provide_default_calibration_params, truncate_targets_from_time, ) from autumn.calibration.utils import add_dispersion_param_prior_for_gaussian from autumn.region import Region from autumn.utils.params import load_targets targets = load_targets("covid_19", Region.JOHOR) notifications = truncate_targets_from_time(targets["notifications"], 310) TARGET_OUTPUTS = [ { "output_key": "notifications", "years": notifications["times"], "values": notifications["values"], "loglikelihood_distri": "normal", }, ] PAR_PRIORS = provide_default_calibration_params() PAR_PRIORS = add_dispersion_param_prior_for_gaussian(PAR_PRIORS, TARGET_OUTPUTS) PAR_PRIORS += [ { "param_name": "contact_rate", "distribution": "uniform", "distri_params": [0.02, 0.05], },
from apps.covid_19 import calibration as base from apps.covid_19.calibration import ( add_standard_dispersion_parameter, add_standard_philippines_params, add_standard_philippines_targets, provide_default_calibration_params, ) from autumn.region import Region from autumn.utils.params import load_targets targets = load_targets("covid_19", Region.DAVAO_CITY) TARGET_OUTPUTS = add_standard_philippines_targets(targets) PAR_PRIORS = provide_default_calibration_params() PAR_PRIORS = add_standard_philippines_params(PAR_PRIORS, Region.DAVAO_CITY) PAR_PRIORS = add_standard_dispersion_parameter(PAR_PRIORS, TARGET_OUTPUTS, "icu_occupancy") PAR_PRIORS = add_standard_dispersion_parameter(PAR_PRIORS, TARGET_OUTPUTS, "accum_deaths") PAR_PRIORS = add_standard_dispersion_parameter(PAR_PRIORS, TARGET_OUTPUTS, "notifications") def run_calibration_chain(max_seconds: int, run_id: int, num_chains: int): base.run_calibration_chain( max_seconds, run_id, num_chains, Region.DAVAO_CITY, PAR_PRIORS, TARGET_OUTPUTS, mode="autumn_mcmc",
from apps.covid_19 import calibration as base from apps.covid_19.calibration import ( provide_default_calibration_params, truncate_targets_from_time, ) from autumn.calibration.utils import add_dispersion_param_prior_for_gaussian from autumn.region import Region from autumn.utils.params import load_targets targets = load_targets("covid_19", Region.MALAYSIA) # Truncate notifications from 1st August 2020 notifications = truncate_targets_from_time(targets["notifications"], 210) TARGET_OUTPUTS = [ { "output_key": "notifications", "years": notifications["times"], "values": notifications["values"], "loglikelihood_distri": "normal", }, { "output_key": "icu_occupancy", "years": [targets["icu_occupancy"]["times"][-1]], "values": [targets["icu_occupancy"]["values"][-1]], "loglikelihood_distri": "normal", }, ] PAR_PRIORS = provide_default_calibration_params() PAR_PRIORS = add_dispersion_param_prior_for_gaussian(PAR_PRIORS,
from apps.covid_19 import calibration as base from apps.covid_19.calibration import ( provide_default_calibration_params, truncate_targets_from_time, ) from autumn.calibration.utils import add_dispersion_param_prior_for_gaussian from autumn.region import Region from autumn.utils.params import load_targets targets = load_targets("covid_19", Region.KUALA_LUMPUR) notifications = truncate_targets_from_time(targets["notifications"], 300) TARGET_OUTPUTS = [ { "output_key": "notifications", "years": notifications["times"], "values": notifications["values"], "loglikelihood_distri": "normal", }, ] PAR_PRIORS = provide_default_calibration_params() PAR_PRIORS = add_dispersion_param_prior_for_gaussian(PAR_PRIORS, TARGET_OUTPUTS) PAR_PRIORS += [ { "param_name": "contact_rate", "distribution": "uniform", "distri_params": [0.02, 0.05], }, {
from apps.covid_19 import calibration as base from apps.covid_19.calibration import ( provide_default_calibration_params, truncate_targets_from_time, ) from autumn.calibration.utils import add_dispersion_param_prior_for_gaussian from autumn.region import Region from autumn.utils.params import load_targets targets = load_targets("covid_19", Region.PENANG) notifications = truncate_targets_from_time(targets["notifications"], 290) TARGET_OUTPUTS = [ { "output_key": "notifications", "years": notifications["times"], "values": notifications["values"], "loglikelihood_distri": "normal", }, ] PAR_PRIORS = provide_default_calibration_params() PAR_PRIORS = add_dispersion_param_prior_for_gaussian(PAR_PRIORS, TARGET_OUTPUTS) PAR_PRIORS += [ { "param_name": "contact_rate", "distribution": "uniform", "distri_params": [0.02, 0.05], },
from apps.covid_19 import calibration as base from apps.covid_19.calibration import provide_default_calibration_params from autumn.calibration.utils import add_dispersion_param_prior_for_gaussian from autumn.region import Region from autumn.utils.params import load_targets targets = load_targets("covid_19", Region.SABAH) notifications = targets["notifications"] deaths = targets["infection_deaths"] TARGET_OUTPUTS = [ { "output_key": "notifications", "years": notifications["times"], "values": notifications["values"], "loglikelihood_distri": "normal", }, # { # "output_key": "infection_deaths", # "years": deaths["times"], # "values": deaths["values"], # "loglikelihood_distri": "normal", # } ] PAR_PRIORS = provide_default_calibration_params() PAR_PRIORS = add_dispersion_param_prior_for_gaussian(PAR_PRIORS, TARGET_OUTPUTS) PAR_PRIORS += [ {
def targets(self): """Returns the calibration targets for the given region""" return load_targets(self.app_name, self.region_name)
from apps.covid_19 import calibration as base from apps.covid_19.calibration import ( add_standard_dispersion_parameter, add_standard_philippines_params, add_standard_philippines_targets, provide_default_calibration_params, ) from autumn.region import Region from autumn.utils.params import load_targets targets = load_targets("covid_19", Region.MANILA) TARGET_OUTPUTS = add_standard_philippines_targets(targets) PAR_PRIORS = provide_default_calibration_params() PAR_PRIORS = add_standard_philippines_params(PAR_PRIORS, Region.MANILA) PAR_PRIORS = add_standard_dispersion_parameter(PAR_PRIORS, TARGET_OUTPUTS, "icu_occupancy") PAR_PRIORS = add_standard_dispersion_parameter(PAR_PRIORS, TARGET_OUTPUTS, "accum_deaths") PAR_PRIORS = add_standard_dispersion_parameter(PAR_PRIORS, TARGET_OUTPUTS, "notifications") def run_calibration_chain(max_seconds: int, run_id: int, num_chains: int): base.run_calibration_chain( max_seconds, run_id, num_chains, Region.MANILA, PAR_PRIORS, TARGET_OUTPUTS, mode="autumn_mcmc",
def powerbi_postprocess(source_db_path: str, target_db_path: str, run_id: str): """ Read the model outputs from a database and then convert them into a form that is readable by our PowerBI dashboard. Save the converted data into its own database. """ source_db = get_database(source_db_path) target_db = get_database(target_db_path) tables_to_copy = [t for t in source_db.table_names() if t != "outputs"] for table_name in tables_to_copy: logger.info("Copying %s", table_name) table_df = source_db.query(table_name) if table_name == "uncertainty": # Rename "time" field to "times" table_df.rename(columns={"time": "times"}) target_db.dump_df(table_name, table_df) app_name, region_name, timestamp, git_commit = read_run_id(run_id) # Add build metadata table build_key = f"{timestamp}-{git_commit}" logger.info("Adding 'build' metadata table with key %s", build_key) build_df = pd.DataFrame.from_dict({ "build_key": [build_key], "app_name": [app_name], "region_name": [region_name] }) target_db.dump_df("build", build_df) # Add scenario metadata table logger.info("Adding 'scenario' metadata table") params = load_params(app_name, region_name) # Add default scenario scenario_data = [{ "scenario": 0, "start_time": int(params["default"]["time"]["start"]), "description": params["default"].get("description", ""), }] for sc_idx, sc_params in params["scenarios"].items(): sc_datum = { "scenario": int(sc_idx), "start_time": int(sc_params["time"]["start"]), "description": sc_params.get("description", ""), } scenario_data.append(sc_datum) scenario_df = pd.DataFrame(scenario_data) target_db.dump_df("scenario", scenario_df) # Add calibration targets logger.info("Adding 'targets' table") targets = load_targets(app_name, region_name) targets_data = [] for target in targets.values(): for t, v in zip(target["times"], target["values"]): t_datum = { "key": target["output_key"], "times": t, "value": v, } targets_data.append(t_datum) targets_df = pd.DataFrame(targets_data) target_db.dump_df("targets", targets_df) logger.info("Converting outputs to PowerBI format") outputs_df = source_db.query("outputs") pbi_outputs_df = unpivot_outputs(outputs_df) target_db.dump_df("powerbi_outputs", pbi_outputs_df) logger.info("Finished creating PowerBI output database at %s", target_db_path)
from apps.covid_19 import calibration as base from apps.covid_19.calibration import ( provide_default_calibration_params, truncate_targets_from_time, ) from autumn.calibration.utils import add_dispersion_param_prior_for_gaussian from autumn.region import Region from autumn.utils.params import load_targets targets = load_targets("covid_19", Region.SELANGOR) notifications = truncate_targets_from_time(targets["notifications"], 270.0) TARGET_OUTPUTS = [ { "output_key": "notifications", "years": notifications["times"], "values": notifications["values"], "loglikelihood_distri": "normal", }, ] PAR_PRIORS = provide_default_calibration_params() PAR_PRIORS = add_dispersion_param_prior_for_gaussian(PAR_PRIORS, TARGET_OUTPUTS) PAR_PRIORS += [ { "param_name": "contact_rate", "distribution": "uniform", "distri_params": [0.018, 0.04], },
def plot_screening_rate(uncertainty_df): n_col = 1 n_row = 1 outputs = ["screening_rate"] panel_h = 5 panel_w = 7 widths = [panel_w] * n_col heights = [panel_h] * n_row fig = pyplot.figure(constrained_layout=True, figsize=(sum(widths), sum(heights))) # (w, h) spec = fig.add_gridspec(ncols=n_col, nrows=n_row, width_ratios=widths, height_ratios=heights) # load targets targets = load_targets("tuberculosis", "marshall_islands") x_low = 1950 x_up = 2050 i_row = 0 i_col = 0 plotted_scenario_ranges = { 0: [x_low, x_up], } for output in outputs: ax = fig.add_subplot(spec[i_row, i_col]) for sc_idx, sc_range in plotted_scenario_ranges.items(): _plot_uncertainty( ax, uncertainty_df, output, sc_idx, sc_range[1], sc_range[0], COLORS[0], start_quantile=0, ) ax.set_ylabel(OUTPUT_TITLES[output], fontsize=20) ax.tick_params(axis="x", labelsize=18) ax.tick_params(axis="y", labelsize=18) ax.set_ylim(ymin=0) i_col += 1 if i_col == n_col: i_col = 0 i_row += 1 values, times = _get_target_values(targets, output) trunc_values = [ v for (v, t) in zip(values, times) if x_low <= t <= x_up ] trunc_times = [ t for (v, t) in zip(values, times) if x_low <= t <= x_up ] _plot_targets_to_axis(ax, trunc_values, trunc_times, on_uncertainty_plot=True) save_figure("screening_rate", FIGURE_PATH)
def get_targets(region_name): return load_targets("covid_19", region_name)
def __init__( self, app_name: str, model_builder: Callable[[dict], StratifiedModel], model_parameters: dict, priors: List[dict], targeted_outputs: List[dict], chain_index: int, total_nb_chains: int, region_name: str, adaptive_proposal: bool = True, initialisation_type: str = InitialisationTypes.LHS, metropolis_init_rel_step_size: float = 0.1, n_steps_fixed_proposal: int = 50, ): self.app_name = app_name self.model_builder = model_builder # a function that builds a new model without running it self.model_parameters = model_parameters self.priors = priors # a list of dictionaries. Each dictionary describes the prior distribution for a parameter self.adaptive_proposal = adaptive_proposal self.metropolis_init_rel_step_size = metropolis_init_rel_step_size self.n_steps_fixed_proposal = n_steps_fixed_proposal self.param_list = [ self.priors[i]["param_name"] for i in range(len(self.priors)) ] # A list of dictionaries. Each dictionary describes a target self.targeted_outputs = targeted_outputs # All model derived outputs to plot, superset of targeted outputs. self.derived_outputs_to_plot = [ t["output_key"] for t in load_targets(app_name, region_name).values() ] # Validate target output start time. model_start = model_parameters["default"]["time"]["start"] max_prior_start = None for p in priors: if p["param_name"] == "time.start": max_prior_start = max(p["distri_params"]) for t in targeted_outputs: t_name = t["output_key"] min_year = min(t["years"]) msg = f"Target {t_name} has time {min_year} before model start {model_start}." assert min_year >= model_start, msg if max_prior_start: msg = f"Target {t_name} has time {min_year} before prior start {max_prior_start}." assert min_year >= max_prior_start, msg # Set a custom end time for all model runs - there is no point running # the models after the last calibration targets. self.end_time = 2 + max([max(t["years"]) for t in targeted_outputs]) self.chain_index = chain_index # work out missing distribution params for priors specify_missing_prior_params(self.priors) # Select starting params self.starting_point = set_initial_point(self.priors, model_parameters, chain_index, total_nb_chains, initialisation_type) # Save metadata output dir. self.output = CalibrationOutputs(chain_index, app_name, region_name) metadata = { "app_name": app_name, "region_name": region_name, "start_time": datetime.now().strftime("%Y-%m-%d--%H-%M-%S"), "git_branch": get_git_branch(), "git_commit": get_git_hash(), } self.output.write_metadata(f"meta-{chain_index}.yml", metadata) self.output.write_metadata(f"params-{chain_index}.yml", model_parameters) self.output.write_metadata(f"priors-{chain_index}.yml", priors) self.output.write_metadata(f"targets-{chain_index}.yml", targeted_outputs) self.data_as_array = None # will contain all targeted data points in a single array self.format_data_as_array() self.workout_unspecified_target_sds() # for likelihood definition self.workout_unspecified_time_weights() # for likelihood weighting self.workout_unspecified_jumping_sds( ) # for proposal function definition self.param_bounds = self.get_parameter_bounds() self.transform = {} self.build_transformations() self.latest_scenario = None self.run_mode = None self.main_table = {} self.mcmc_trace_matrix = None # will store the results of the MCMC model calibration self.mle_estimates = { } # will store the results of the maximum-likelihood calibration self.evaluated_params_ll = [ ] # list of tuples: [(theta_0, ll_0), (theta_1, ll_1), ...] if self.chain_index == 0: plots.calibration.plot_pre_calibration(self.priors, self.output.output_dir) self.is_vic_super_model = False if "victorian_clusters" in self.model_parameters["default"]: if self.model_parameters["default"]["victorian_clusters"]: self.is_vic_super_model = True
from apps.covid_19 import calibration as base from apps.covid_19.calibration import ( add_standard_dispersion_parameter, add_standard_philippines_params, add_standard_philippines_targets, provide_default_calibration_params, ) from autumn.region import Region from autumn.utils.params import load_targets targets = load_targets("covid_19", Region.CENTRAL_VISAYAS) TARGET_OUTPUTS = add_standard_philippines_targets(targets) PAR_PRIORS = provide_default_calibration_params() PAR_PRIORS = add_standard_philippines_params(PAR_PRIORS, Region.CENTRAL_VISAYAS) PAR_PRIORS = add_standard_dispersion_parameter(PAR_PRIORS, TARGET_OUTPUTS, "icu_occupancy") PAR_PRIORS = add_standard_dispersion_parameter(PAR_PRIORS, TARGET_OUTPUTS, "accum_deaths") PAR_PRIORS = add_standard_dispersion_parameter(PAR_PRIORS, TARGET_OUTPUTS, "notifications") def run_calibration_chain(max_seconds: int, run_id: int, num_chains: int): base.run_calibration_chain( max_seconds, run_id, num_chains, Region.CENTRAL_VISAYAS, PAR_PRIORS, TARGET_OUTPUTS,
import logging from apps.tuberculosis_strains.model import build_model from autumn.calibration import Calibration from autumn.region import Region from autumn.utils.params import load_params, load_targets targets = load_targets("tuberculosis_strains", Region.PHILIPPINES) prevalence_infectious = targets["prevalence_infectious"] # population_size = targets["population_size"] incidence = targets["incidence"] def run_calibration_chain(max_seconds: int, run_id: int, num_chains: int): params = load_params("tuberculosis_strains", Region.PHILIPPINES) calib = Calibration( "tuberculosis_strains", build_model, params, PRIORS, TARGET_OUTPUTS, run_id, num_chains, region_name=Region.PHILIPPINES, ) calib.run_fitting_algorithm( run_mode="autumn_mcmc", n_chains=1, available_time=max_seconds, haario_scaling_factor=params["default"]["haario_scaling_factor"], )
import logging from apps.sir_example.model import build_model from autumn.calibration import Calibration from autumn.region import Region from autumn.utils.params import load_params, load_targets targets = load_targets("sir_example", Region.PHILIPPINES) prevalence_infectious = targets["prevalence_infectious"] def run_calibration_chain(max_seconds: int, run_id: int, num_chains: int): params = load_params("sir_example", Region.PHILIPPINES) calib = Calibration( "sir_example", build_model, params, PRIORS, TARGET_OUTPUTS, run_id, num_chains, region_name=Region.PHILIPPINES, ) calib.run_fitting_algorithm( run_mode="autumn_mcmc", n_chains=1, available_time=max_seconds, ) PRIORS = [
from apps.covid_19 import calibration as base from apps.covid_19.calibration import ( add_standard_dispersion_parameter, add_standard_philippines_params, add_standard_philippines_targets, provide_default_calibration_params, ) from autumn.region import Region from autumn.utils.params import load_targets targets = load_targets("covid_19", Region.PHILIPPINES) TARGET_OUTPUTS = add_standard_philippines_targets(targets) PAR_PRIORS = provide_default_calibration_params() PAR_PRIORS = add_standard_philippines_params(PAR_PRIORS, Region.PHILIPPINES) PAR_PRIORS = add_standard_dispersion_parameter(PAR_PRIORS, TARGET_OUTPUTS, "icu_occupancy") PAR_PRIORS = add_standard_dispersion_parameter(PAR_PRIORS, TARGET_OUTPUTS, "accum_deaths") PAR_PRIORS = add_standard_dispersion_parameter(PAR_PRIORS, TARGET_OUTPUTS, "notifications") def run_calibration_chain(max_seconds: int, run_id: int, num_chains: int): base.run_calibration_chain( max_seconds, run_id, num_chains, Region.PHILIPPINES, PAR_PRIORS, TARGET_OUTPUTS, mode="autumn_mcmc",
from apps.covid_19 import calibration as base from apps.covid_19.calibration import ( add_standard_dispersion_parameter, add_standard_philippines_params, add_standard_philippines_targets, provide_default_calibration_params, ) from autumn.region import Region from autumn.utils.params import load_targets targets = load_targets("covid_19", Region.CALABARZON) TARGET_OUTPUTS = add_standard_philippines_targets(targets) PAR_PRIORS = provide_default_calibration_params() PAR_PRIORS = add_standard_philippines_params(PAR_PRIORS, Region.CALABARZON) PAR_PRIORS = add_standard_dispersion_parameter(PAR_PRIORS, TARGET_OUTPUTS, "icu_occupancy") PAR_PRIORS = add_standard_dispersion_parameter(PAR_PRIORS, TARGET_OUTPUTS, "accum_deaths") PAR_PRIORS = add_standard_dispersion_parameter(PAR_PRIORS, TARGET_OUTPUTS, "notifications") def run_calibration_chain(max_seconds: int, run_id: int, num_chains: int): base.run_calibration_chain( max_seconds, run_id, num_chains, Region.CALABARZON, PAR_PRIORS, TARGET_OUTPUTS, mode="autumn_mcmc", adaptive_proposal=True, )