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,
)
